discordrb 1.2.0 → 1.3.0

data/lib/discordrb/commands/command-bot.rb

@@ -0,0 +1,135 @@
+require 'discordrb/bot'
+require 'discordrb/data'
+require 'discordrb/commands/parser'
+
+# Specialized bot to run commands
+
+module Discordrb::Commands
+  class CommandBot < Discordrb::Bot
+    attr_reader :attributes, :prefix
+
+    def initialize(email, password, prefix, attributes = {}, debug = false)
+      super(email, password, debug)
+      @prefix = prefix
+      @commands = {}
+      @attributes = {
+        # Whether advanced functionality such as command chains are enabled
+        advanced_functionality: attributes[:advanced_functionality].nil? ? true : attributes[:advanced_functionality],
+
+        # The name of the help command (that displays information to other commands). Nil if none should exist
+        help_command: attributes[:help_command] || :help,
+
+        # All of the following need to be one character
+        # String to designate previous result in command chain
+        previous: attributes[:previous] || '~',
+
+        # Command chain delimiter
+        chain_delimiter: attributes[:chain_delimiter] || '>',
+
+        # Chain argument delimiter
+        chain_args_delim: attributes[:chain_args_delim] || ':',
+
+        # Sub-chain starting character
+        sub_chain_start: attributes[:sub_chain_start] || '[',
+
+        # Sub-chain ending character
+        sub_chain_end: attributes[:sub_chain_end] || ']',
+
+        # Quoted mode starting character
+        quote_start: attributes[:quote_start] || '"',
+
+        # Quoted mode ending character
+        quote_end: attributes[:quote_end] || '"'
+      }
+
+      @permissions = {
+        roles: {},
+        users: {}
+      }
+
+      if @attributes[:help_command]
+        command(@attributes[:help_command], max_args: 1, description: 'Shows a list of all the commands available or displays help for a specific command.', usage: 'help [command name]') do |event, command_name|
+          if command_name
+            command = @commands[command_name.to_sym]
+            unless command
+              return "The command `#{command_name}` does not exist!"
+            end
+            desc = command.attributes[:description] || '*No description available*'
+            usage = command.attributes[:usage]
+            result = "**`#{command_name}`**: #{desc}"
+            result << "\nUsage: `#{usage}`" if usage
+          else
+            available_commands = @commands.values.reject { |command| !command.attributes[:help_available] }
+            case available_commands.length
+            when 0..5
+              available_commands.reduce "**List of commands:**\n" do |memo, command|
+                memo + "**`#{command.name}`**: #{command.attributes[:description] || '*No description available*'}\n"
+              end
+            when 5..50
+              (available_commands.reduce "**List of commands:**\n" do |memo, command|
+                memo + "`#{command.name}`, "
+              end)[0..-3]
+            else
+              event.user.pm (available_commands.reduce "**List of commands:**\n" do |memo, command|
+                memo + "`#{command.name}`, "
+              end)[0..-3]
+              "Sending list in PM!"
+            end
+          end
+        end
+      end
+    end
+
+    def command(name, attributes = {}, &block)
+      @commands[name] = Command.new(name, attributes, &block)
+    end
+
+    def execute_command(name, event, arguments, chained = false)
+      debug("Executing command #{name} with arguments #{arguments}")
+      command = @commands[name]
+      unless command
+        event.respond "The command `#{name}` doesn't exist!"
+        return
+      end
+      if permission?(user(event.user.id), command.attributes[:permission_level], event.server.id)
+        command.call(event, arguments, chained)
+      else
+        event.respond "You don't have permission to execute command `#{name}`!"
+        return
+      end
+    end
+
+    def simple_execute(chain, event)
+      args = chain.split(' ')
+      execute_command(args[0].to_sym, event, args[1..-1])
+    end
+
+    def create_message(data)
+      message = Discordrb::Message.new(data, self)
+      event = Discordrb::Events::MessageEvent.new(message, self)
+
+      if message.content.start_with? @prefix
+        chain = message.content[@prefix.length..-1]
+        debug("Parsing command chain #{chain}")
+        result = (@attributes[:advanced_functionality]) ? CommandChain.new(chain, self).execute(event) : simple_execute(chain, event)
+        p result
+        event.respond result if result
+      end
+    end
+
+    def set_user_permission(id, level)
+      @permissions[:users][id] = level
+    end
+
+    def set_role_permission(id, level)
+      @permissions[:roles][id] = level
+    end
+
+    def permission?(user, level, server_id)
+      determined_level = user.roles[server_id].each.reduce(0) do |memo, role|
+        [@permissions[:roles][role.id] || 0, memo].max
+      end
+      [@permissions[:users][user.id] || 0, determined_level].max >= level
+    end
+  end
+end

data/lib/discordrb/commands/parser.rb

@@ -0,0 +1,210 @@
+module Discordrb::Commands
+  class Command
+    attr_reader :attributes, :name
+
+    def initialize(name, attributes = {}, &block)
+      @name = name
+      @attributes = {
+        # The lowest permission level that can use the command
+        permission_level: attributes[:permission_level] || 0,
+
+        # Whether this command is usable in a command chain
+        chain_usable: attributes[:chain_usable].nil? ? true : attributes[:chain_usable],
+
+        # Whether this command should show up in the help command
+        help_available: attributes[:help_available].nil? ? true : attributes[:help_available],
+
+        # Description (for help command)
+        description: attributes[:description] || nil,
+
+        # Usage description (for help command and error messages)
+        usage: attributes[:usage] || nil,
+
+        # Minimum number of arguments
+        min_args: attributes[:min_args] || 0,
+
+        # Maximum number of arguments (-1 for no limit)
+        max_args: attributes[:max_args] || -1
+      }
+
+      @block = block
+    end
+
+    def call(event, arguments, chained = false)
+      if arguments.length < @attributes[:min_args]
+        event.respond "Too few arguments for command `#{name}`!"
+        event.respond "Usage: `#{@attributes[:usage]}`" if @attributes[:usage]
+        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]
+        return
+      end
+      unless @attributes[:chain_usable]
+        if chained
+          event.respond "Command `#{name}` cannot be used in a command chain!"
+          return
+        end
+      end
+      @block.call(event, *arguments)
+    end
+  end
+
+  class CommandChain
+    def initialize(chain, bot, subchain = false)
+      @attributes = bot.attributes
+      @chain = chain
+      @bot = bot
+      @subchain = subchain
+    end
+
+    def execute_bare(event)
+      b_start, b_level = -1, 0
+      result = ''
+      quoted = false
+      hacky_delim, hacky_space, hacky_prev = [0xe001, 0xe002, 0xe003].pack('U*').chars
+
+      @chain.each_char.each_with_index do |char, index|
+        # Quote begin
+        if char == @attributes[:quote_start] && !quoted
+          quoted = 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
+          next
+        end
+
+        if char == ' ' && quoted
+          result += hacky_space
+          next
+        end
+
+        if char == @attributes[:sub_chain_start] && !quoted
+          b_start = index if b_level == 0
+          b_level += 1
+        end
+
+        result << char if b_level <= 0
+
+        if char == @attributes[:sub_chain_end] && !quoted
+          b_level -= 1
+          if b_level == 0
+            nested = @chain[b_start + 1 .. index - 1]
+            subchain = CommandChain.new(nested, @bot, true)
+            result << subchain.execute(event)
+          end
+        end
+      end
+
+      event.respond("Your subchains are mismatched! Make sure you don't have any extra #{@attributes[:sub_chain_start]}'s or #{@attributes[:sub_chain_end]}'s") unless b_level == 0
+
+      @chain = result
+
+      @chain_args, @chain = divide_chain(@chain)
+
+      prev = ''
+
+      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])
+
+      first = true
+      split_chain = chain_to_split.split(@attributes[:chain_delimiter])
+      split_chain.each do |command|
+        command = @attributes[:chain_delimiter] + command if first && @chain.start_with?(@attributes[:chain_delimiter])
+        first = false
+
+        command.strip!
+
+        # Replace the hacky delimiter that was used inside quotes with actual delimiters
+        command.gsub! hacky_delim, @attributes[:chain_delimiter]
+
+        first_space = command.index ' '
+        command_name = first_space ? command[0..first_space-1] : command
+        arguments = first_space ? command[first_space+1..-1] : ''
+
+        # Append a previous sign if none is present
+        arguments << @attributes[:previous] unless arguments.include? @attributes[:previous]
+        arguments.gsub! @attributes[:previous], prev
+
+        # Replace hacky previous signs with actual ones
+        arguments.gsub! hacky_prev, @attributes[:previous]
+
+        arguments = arguments.split ' '
+
+        # Replace the hacky spaces with actual spaces
+        arguments.map! do |elem|
+          elem.gsub hacky_space, ' '
+        end
+
+        # Finally execute the command
+        prev = @bot.execute_command(command_name.to_sym, event, arguments, split_chain.length > 1 || @subchain)
+      end
+
+      prev
+    end
+
+    def execute(event)
+      old_chain = @chain
+      @bot.debug "Executing bare chain"
+      result = execute_bare(event)
+
+      @chain_args ||= []
+
+      @bot.debug "Found chain args #{@chain_args}, preliminary result #{result}"
+
+      @chain_args.each do |arg|
+        case arg.first
+        when 'repeat'
+          new_result = ''
+          executed_chain = divide_chain(old_chain).last
+
+          arg[1].to_i.times do
+            new_result << CommandChain.new(executed_chain, @bot).execute(event)
+          end
+
+          result = new_result
+        # TODO: more chain arguments
+        end
+      end
+
+      result
+    end
+
+    private
+
+    def divide_chain(chain)
+      chain_args_index = chain.index @attributes[:chain_args_delim]
+      chain_args = []
+
+      if chain_args_index
+        chain_args = chain[0..chain_args_index].split ','
+
+        # Split up the arguments
+
+        chain_args.map! do |arg|
+          arg.split ' '
+        end
+
+        chain = chain[chain_args_index+1..-1]
+      end
+
+      [chain_args, chain]
+    end
+  end
+end

data/lib/discordrb/data.rb

@@ -1,391 +1,341 @@
-# These classes hold relevant Discord data, such as messages or channels.
-
-require 'ostruct'
-
-module Discordrb
-  class User
-    attr_reader :username, :id, :discriminator, :avatar
-    
-    attr_accessor :status
-    attr_accessor :game_id
-    attr_accessor :server_mute
-    attr_accessor :server_deaf
-    attr_accessor :self_mute
-    attr_accessor :self_deaf
-    attr_reader :voice_channel
-    attr_reader :roles
-
-    alias_method :name, :username
-
-    def initialize(data, bot, server = nil)
-      @bot = bot
-
-      @username = data['username']
-      @id = data['id'].to_i
-      @discriminator = data['discriminator']
-      @avatar = data['avatar']
-      @server = server
-      @roles = []
-      
-      @status = :offline
-    end
-
-    # Utility function to mention users in messages
-    def mention
-      "<@#{@id}>"
-    end
-
-    # Utility function to send a PM
-    def pm(content = nil)
-      if content
-        # Recursively call pm to get the channel, then send a message to it
-        channel = pm
-        channel.send_message(content)
-      else
-        # If no message was specified, return the PM channel
-        @bot.private_channel(@id)
-      end
-    end
-    
-    # Move a user into a voice channel
-    def move(to_channel)
-      return if to_channel && to_channel.type != 'voice'
-      @voice_channel = to_channel
-    end
-    
-    # Set this user's roles
-    def update_roles(roles)
-      @roles = roles
-    end
-    
-    # Determine if the user has permission to do an action
-    # action is a permission from Permissions::Flags.
-    # channel is the channel in which the action takes place (not applicable for server-wide actions).
-    def has_permission?(action, channel = nil)
-      # For each role, check if
-      #   (1) the channel explicitly allows or permits an action for the role and
-      #   (2) if the user is allowed to do the action if the channel doesn't specify
-      @roles.reduce(false) do |can_act, role|
-        channel_allow = nil
-        if channel && channel.permission_overwrites[role.id]
-          allow = channel.permission_overwrites[role.id].allow
-          deny = channel.permission_overwrites[role.id].deny
-          if allow.instance_variable_get("@#{action}")
-            channel_allow = true
-          elsif deny.instance_variable_get("@#{action}")
-            channel_allow = false
-          # else
-          #   If the channel has nothing to say on the matter, we can defer to the role itself
-          end
-        end
-        if channel_allow == false
-          can_act = can_act || false
-        elsif channel_allow == true
-          can_act = true
-        else # channel_allow == nil
-          can_act = role.permissions.instance_variable_get("@#{action}") || can_act
-        end
-      end
-    end
-    
-    def method_missing(method_name, *args, &block)
-      if /\Acan_(?<action>\w+)\?\Z/ =~ method_name
-        action = action.to_sym
-        if Permissions::Flags.has_value? action
-          has_permission? action, args.first
-        else
-          super
-        end
-      else
-        super
-      end
-    end
-    
-    # Respond to can_*? methods
-    def respond_to?(method_name, include_private = false)
-      if /\Acan_(?<action>\w+)\?\Z/ =~ method_name
-        action = action.to_sym
-        if Permissions::Flags.has_value? action
-          true
-        else
-          super
-        end
-      else
-        super
-      end
-    end
-  end
-  
-  class Role
-    attr_reader :permissions
-    attr_reader :name
-    attr_reader :id
-    attr_reader :hoist
-    attr_reader :color
-    
-    def initialize(data, bot, server = nil)
-      @permissions = Permissions.new(data['permissions'])
-      @name = data['name']
-      @id = data['id'].to_i
-      @hoist = data['hoist']
-      @color = ColorRGB.new(data['color'])
-    end
-    
-    def update_from(other)
-      @permissions = other.permissions
-      @name = other.name
-      @hoist = other.hoist
-      @color = other.color
-    end
-  end
-  
-  class Permissions
-    # This hash maps bit positions to logical permissions.
-    # I'm not sure what the unlabeled bits are reserved for.
-    Flags = {
-      # Bit => Permission # Value
-      0 => :create_instant_invite, # 1
-      1 => :kick_members,          # 2
-      2 => :ban_members,           # 4
-      3 => :manage_roles ,         # 8
-      4 => :manage_channels,       # 16
-      5 => :manage_server,         # 32
-      #6                           # 64
-      #7                           # 128
-      #8                           # 256
-      #9                           # 512
-      10 => :read_messages,        # 1024
-      11 => :send_messages,        # 2048
-      12 => :send_tts_messages,    # 4096
-      13 => :manage_messages,      # 8192
-      14 => :embed_links,          # 16384
-      15 => :attach_files,         # 32768
-      16 => :read_message_history, # 65536
-      17 => :mention_everyone,     # 131072
-      #18                          # 262144
-      #19                          # 524288
-      20 => :connect,              # 1048576
-      21 => :speak,                # 2097152
-      22 => :mute_members,         # 4194304
-      23 => :deafen_members,       # 8388608
-      24 => :move_members,         # 16777216
-      25 => :use_voice_activity    # 33554432
-    }
-             
-    Flags.each_value do |flag|
-      attr_reader flag
-    end
-  
-    def initialize(bits)
-      Flags.each do |position, flag|
-        flag_set = ((bits >> position) & 0x1) == 1
-        instance_variable_set "@#{flag}", flag_set
-      end
-    end
-  end
-
-  class Channel
-    attr_reader :name, :server, :type, :id, :is_private, :recipient, :topic
-    
-    attr_reader :permission_overwrites
-
-    def initialize(data, bot, server = nil)
-      @bot = bot
-
-      #data is a sometimes a Hash and othertimes an array of Hashes, you only want the last one if it's an array
-      data = data[-1] if data.is_a?(Array)
-
-      @id = data['id'].to_i
-      @type = data['type'] || 'text'
-      @topic = data['topic']
-
-      @is_private = data['is_private']
-      if @is_private
-        @recipient = User.new(data['recipient'], bot)
-        @name = @recipient.username
-      else
-        @name = data['name']
-        @server = bot.server(data['guild_id'].to_i)
-        @server = server if !@server
-      end
-      
-      # Populate permission overwrites
-      @permission_overwrites = {}
-      if data['permission_overwrites']
-        data['permission_overwrites'].each do |element|
-          role_id = element['id'].to_i
-          deny = Permissions.new(element['deny'])
-          allow = Permissions.new(element['allow'])
-          @permission_overwrites[role_id] = OpenStruct.new
-          @permission_overwrites[role_id].deny = deny
-          @permission_overwrites[role_id].allow = allow
-        end
-      end
-    end
-
-    def send_message(content)
-      @bot.send_message(@id, content)
-    end
-    
-    def update_from(other)
-      @topic = other.topic
-      @name = other.name
-      @is_private = other.is_private
-      @recipient = other.recipient
-      @permission_overwrites = other.permission_overwrites
-    end
-    
-    # List of users currently in a channel
-    def users
-      if @type == 'text'
-        @server.members.select {|u| u.status != :offline }
-      else
-        @server.members.select do |user|
-          if user.voice_channel
-            user.voice_channel.id == @id
-          end
-        end
-      end
-    end
-    
-    def update_overwrites(overwrites)
-      @permission_overwrites = overwrites
-    end
-
-    alias_method :send, :send_message
-    alias_method :message, :send_message
-  end
-
-  class Message
-    attr_reader :content, :author, :channel, :timestamp, :id, :mentions
-    alias_method :user, :author
-    alias_method :text, :content
-
-    def initialize(data, bot)
-      @bot = bot
-      @content = data['content']
-      @author = User.new(data['author'], bot)
-      @channel = bot.channel(data['channel_id'].to_i)
-      @timestamp = Time.at(data['timestamp'].to_i)
-      @id = data['id'].to_i
-
-      @mentions = []
-
-      data['mentions'].each do |element|
-        @mentions << User.new(element, bot)
-      end
-    end
-  end
-
-  class Server
-    attr_reader :region, :name, :owner_id, :id, :members
-
-    # Array of channels on the server
-    attr_reader :channels
-    
-    # Array of roles on the server
-    attr_reader :roles
-
-    def initialize(data, bot)
-      @bot = bot
-      @region = data['region']
-      @name = data['name']
-      @owner_id = data['owner_id'].to_i
-      @id = data['id'].to_i
-      
-      # Create roles
-      @roles = []
-      roles_by_id = {}
-      data['roles'].each do |element|
-        role = Role.new(element, bot)
-        @roles << role
-        roles_by_id[role.id] = role
-      end
-      
-      @members = []
-      members_by_id = {}
-
-      data['members'].each do |element|
-        user = User.new(element['user'], bot, self)
-        @members << user
-        members_by_id[user.id] = user
-        user_roles = []
-        element['roles'].each do |element|
-          role_id = element.to_i
-          user_roles << roles_by_id[role_id]
-        end
-        user.update_roles(user_roles)
-      end
-
-      # Update user statuses with presence info
-      if data['presences']
-        data['presences'].each do |element|
-          if element['user']
-            user_id = element['user']['id'].to_i
-            user = members_by_id[user_id]
-            if user
-              user.status = element['status'].to_sym
-              user.game_id = element['game_id']
-            end
-          end
-        end
-      end
-      
-      @channels = []
-      channels_by_id = {}
-
-      if data['channels']
-        data['channels'].each do |element|
-          channel = Channel.new(element, bot, self)
-          @channels << channel
-          channels_by_id[channel.id] = channel
-        end
-      end
-      
-      if data['voice_states']
-        data['voice_states'].each do |element|
-          user_id = element['user_id'].to_i
-          user = members_by_id[user_id]
-          if user
-            user.server_mute = element['mute']
-            user.server_deaf = element['deaf']
-            user.self_mute = element['self_mute']
-            user.self_mute = element['self_mute']
-            channel_id = element['channel_id']
-            channel = nil
-            if channel_id
-              channel = channels_by_id[channel_id]
-            end
-            user.move(channel)
-          end
-        end
-      end
-    end
-    
-    def add_role(role)
-      @roles << role
-    end
-    
-    def delete_role(role_id)
-      @roles.reject! {|r| r.id == role_id}
-      @members.each do |user|
-        new_roles = user.roles.reject {|r| r.id == role_id}
-        user.update_roles(new_roles)
-      end
-      @channels.each do |channel|
-        overwrites = channel.permission_overwrites.reject {|id, perm| id == role_id}
-        channel.update_overwrites(overwrites)
-      end
-    end
-  end
-  
-  class ColorRGB
-    attr_reader :red, :green, :blue
-    
-    def initialize(combined)
-      @red = (combined >> 16) & 0xFF
-      @green = (combined >> 8) & 0xFF
-      @blue = combined & 0xFF
-    end
-  end
-end
+# These classes hold relevant Discord data, such as messages or channels.
+
+require 'ostruct'
+require 'discordrb/permissions'
+
+module Discordrb
+  class User
+    attr_reader :username, :id, :discriminator, :avatar
+
+    attr_accessor :status
+    attr_accessor :game_id
+    attr_accessor :server_mute
+    attr_accessor :server_deaf
+    attr_accessor :self_mute
+    attr_accessor :self_deaf
+    attr_reader :voice_channel
+
+    # Hash of user roles.
+    # Key: Server ID
+    # Value: Array of roles.
+    attr_reader :roles
+
+    alias_method :name, :username
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @username = data['username']
+      @id = data['id'].to_i
+      @discriminator = data['discriminator']
+      @avatar = data['avatar']
+      @roles = {}
+
+      @status = :offline
+    end
+
+    # Utility function to mention users in messages
+    def mention
+      "<@#{@id}>"
+    end
+
+    # Utility function to send a PM
+    def pm(content = nil)
+      if content
+        # Recursively call pm to get the channel, then send a message to it
+        channel = pm
+        channel.send_message(content)
+      else
+        # If no message was specified, return the PM channel
+        @bot.private_channel(@id)
+      end
+    end
+
+    # Move a user into a voice channel
+    def move(to_channel)
+      return if to_channel && to_channel.type != 'voice'
+      @voice_channel = to_channel
+    end
+
+    # Set this user's roles
+    def update_roles(server, roles)
+      @roles[server.id] = roles
+    end
+
+    # Merge this user's roles with the roles from another instance of this user (from another server)
+    def merge_roles(server, roles)
+      if @roles[server.id]
+        @roles[server.id] = (@roles[server.id] + roles).uniq
+      else
+        @roles[server.id] = roles
+      end
+    end
+
+    # Determine if the user has permission to do an action
+    # action is a permission from Permissions::Flags.
+    # channel is the channel in which the action takes place (not applicable for server-wide actions).
+    def has_permission?(action, server, channel = nil)
+      # For each role, check if
+      #   (1) the channel explicitly allows or permits an action for the role and
+      #   (2) if the user is allowed to do the action if the channel doesn't specify
+      return false if !@roles[server.id]
+
+      @roles[server.id].reduce(false) do |can_act, role|
+        channel_allow = nil
+        if channel && channel.permission_overwrites[role.id]
+          allow = channel.permission_overwrites[role.id].allow
+          deny = channel.permission_overwrites[role.id].deny
+          if allow.instance_variable_get("@#{action}")
+            channel_allow = true
+          elsif deny.instance_variable_get("@#{action}")
+            channel_allow = false
+          # else
+          #   If the channel has nothing to say on the matter, we can defer to the role itself
+          end
+        end
+        if channel_allow == false
+          can_act = can_act || false
+        elsif channel_allow == true
+          can_act = true
+        else # channel_allow == nil
+          can_act = role.permissions.instance_variable_get("@#{action}") || can_act
+        end
+      end
+    end
+
+    # Define methods for querying permissions
+    Discordrb::Permissions::Flags.each_value do |flag|
+      define_method "can_#{flag}?" do |server, channel = nil|
+        has_permission? flag, server, channel
+      end
+    end
+  end
+
+  class Role
+    attr_reader :permissions
+    attr_reader :name
+    attr_reader :id
+    attr_reader :hoist
+    attr_reader :color
+
+    def initialize(data, bot, server = nil)
+      @permissions = Permissions.new(data['permissions'])
+      @name = data['name']
+      @id = data['id'].to_i
+      @hoist = data['hoist']
+      @color = ColorRGB.new(data['color'])
+    end
+
+    def update_from(other)
+      @permissions = other.permissions
+      @name = other.name
+      @hoist = other.hoist
+      @color = other.color
+    end
+  end
+
+  class Channel
+    attr_reader :name, :server, :type, :id, :is_private, :recipient, :topic
+
+    attr_reader :permission_overwrites
+
+    def initialize(data, bot, server = nil)
+      @bot = bot
+
+      #data is a sometimes a Hash and othertimes an array of Hashes, you only want the last one if it's an array
+      data = data[-1] if data.is_a?(Array)
+
+      @id = data['id'].to_i
+      @type = data['type'] || 'text'
+      @topic = data['topic']
+
+      @is_private = data['is_private']
+      if @is_private
+        @recipient = User.new(data['recipient'], bot)
+        @name = @recipient.username
+      else
+        @name = data['name']
+        @server = bot.server(data['guild_id'].to_i)
+        @server = server if !@server
+      end
+
+      # Populate permission overwrites
+      @permission_overwrites = {}
+      if data['permission_overwrites']
+        data['permission_overwrites'].each do |element|
+          role_id = element['id'].to_i
+          deny = Permissions.new(element['deny'])
+          allow = Permissions.new(element['allow'])
+          @permission_overwrites[role_id] = OpenStruct.new
+          @permission_overwrites[role_id].deny = deny
+          @permission_overwrites[role_id].allow = allow
+        end
+      end
+    end
+
+    def send_message(content)
+      @bot.send_message(@id, content)
+    end
+
+    def update_from(other)
+      @topic = other.topic
+      @name = other.name
+      @is_private = other.is_private
+      @recipient = other.recipient
+      @permission_overwrites = other.permission_overwrites
+    end
+
+    # List of users currently in a channel
+    def users
+      if @type == 'text'
+        @server.members.select {|u| u.status != :offline }
+      else
+        @server.members.select do |user|
+          if user.voice_channel
+            user.voice_channel.id == @id
+          end
+        end
+      end
+    end
+
+    def update_overwrites(overwrites)
+      @permission_overwrites = overwrites
+    end
+
+    alias_method :send, :send_message
+    alias_method :message, :send_message
+  end
+
+  class Message
+    attr_reader :content, :author, :channel, :timestamp, :id, :mentions
+    alias_method :user, :author
+    alias_method :text, :content
+
+    def initialize(data, bot)
+      @bot = bot
+      @content = data['content']
+      @author = User.new(data['author'], bot)
+      @channel = bot.channel(data['channel_id'].to_i)
+      @timestamp = Time.at(data['timestamp'].to_i)
+      @id = data['id'].to_i
+
+      @mentions = []
+
+      data['mentions'].each do |element|
+        @mentions << User.new(element, bot)
+      end
+    end
+  end
+
+  class Server
+    attr_reader :region, :name, :owner_id, :id, :members
+
+    # Array of channels on the server
+    attr_reader :channels
+
+    # Array of roles on the server
+    attr_reader :roles
+
+    def initialize(data, bot)
+      @bot = bot
+      @region = data['region']
+      @name = data['name']
+      @owner_id = data['owner_id'].to_i
+      @id = data['id'].to_i
+
+      # Create roles
+      @roles = []
+      roles_by_id = {}
+      data['roles'].each do |element|
+        role = Role.new(element, bot)
+        @roles << role
+        roles_by_id[role.id] = role
+      end
+
+      @members = []
+      members_by_id = {}
+
+      data['members'].each do |element|
+        user = User.new(element['user'], bot)
+        @members << user
+        members_by_id[user.id] = user
+        user_roles = []
+        element['roles'].each do |element|
+          role_id = element.to_i
+          user_roles << roles_by_id[role_id]
+        end
+        user.update_roles(self, user_roles)
+      end
+
+      # Update user statuses with presence info
+      if data['presences']
+        data['presences'].each do |element|
+          if element['user']
+            user_id = element['user']['id'].to_i
+            user = members_by_id[user_id]
+            if user
+              user.status = element['status'].to_sym
+              user.game_id = element['game_id']
+            end
+          end
+        end
+      end
+
+      @channels = []
+      channels_by_id = {}
+
+      if data['channels']
+        data['channels'].each do |element|
+          channel = Channel.new(element, bot, self)
+          @channels << channel
+          channels_by_id[channel.id] = channel
+        end
+      end
+
+      if data['voice_states']
+        data['voice_states'].each do |element|
+          user_id = element['user_id'].to_i
+          user = members_by_id[user_id]
+          if user
+            user.server_mute = element['mute']
+            user.server_deaf = element['deaf']
+            user.self_mute = element['self_mute']
+            user.self_mute = element['self_mute']
+            channel_id = element['channel_id']
+            channel = nil
+            if channel_id
+              channel = channels_by_id[channel_id]
+            end
+            user.move(channel)
+          end
+        end
+      end
+    end
+
+    def add_role(role)
+      @roles << role
+    end
+
+    def delete_role(role_id)
+      @roles.reject! {|r| r.id == role_id}
+      @members.each do |user|
+        new_roles = user.roles.reject {|r| r.id == role_id}
+        user.update_roles(self, new_roles)
+      end
+      @channels.each do |channel|
+        overwrites = channel.permission_overwrites.reject {|id, perm| id == role_id}
+        channel.update_overwrites(overwrites)
+      end
+    end
+  end
+
+  class ColorRGB
+    attr_reader :red, :green, :blue
+
+    def initialize(combined)
+      @red = (combined >> 16) & 0xFF
+      @green = (combined >> 8) & 0xFF
+      @blue = combined & 0xFF
+    end
+  end
+end