discordrb 1.3.8 → 1.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5a55f754d7cf84a63dad52ba95b782438e62f20
-  data.tar.gz: c361301ca0e4bd83ca760e3cadbd2f61763ef71d
+  metadata.gz: 569e1f420904120c2bcc90a4d3210dcd6e2bbb33
+  data.tar.gz: 4aa9f7b948e80d2b510981089df082fe3b25e536
 SHA512:
-  metadata.gz: 038066abf5b878806fa34942ed379dedf9837019d55c8c27c487fe6a2cebee2fa09633f84295ef6ab83713ef71912c40ca2501ab385a64bbdff72d810f80eab8
-  data.tar.gz: 7062dd91aba1b07001054f73a20137bac3d90e7751c06778812b5d5740c61dcfd36b6d07d4c72149d8cae44f24c5768ec64dbb01ca93403040e9d2b6586d09d5
+  metadata.gz: 4ccdf4a5c16ea40690f0bcd522c7532bf71a857bd006a7b332484409ae1ecdb68380673250c5d96850be92ede58381af76f4d5154f26ff59e0dcdc8b2e51990c
+  data.tar.gz: 5cd3c4927f10709b9605f242da79d9cc881d3cd466eab30b3996d5827fb6dae2619e2f6a160fa22ca8750a614d6926389dccbffa5d1b40908319633423400d34

data/lib/discordrb.rb

@@ -4,5 +4,4 @@ require 'discordrb/commands/command_bot'
 
 # All discordrb functionality, to be extended by other files
 module Discordrb
-  # Your code goes here...
 end

data/lib/discordrb/api.rb

@@ -15,6 +15,22 @@ module Discordrb::API
     )
   end
 
+  # Unban a user from a server
+  def unban_user(token, server_id, user_id)
+    RestClient.delete(
+      "#{APIBASE}/guilds/#{server_id}/bans/#{user_id}",
+      Authorization: token
+    )
+  end
+
+  # Kick a user from a server
+  def kick_user(token, server_id, user_id)
+    RestClient.delete(
+      "#{APIBASE}/guilds/#{server_id}/members/#{user_id}",
+      Authorization: token
+    )
+  end
+
   # Get a server's banned users
   def bans(token, server_id)
     RestClient.get(

data/lib/discordrb/await.rb

@@ -0,0 +1,23 @@
+module Discordrb
+  # Class that represents an await to wait for a further event
+  class Await
+    attr_reader :key, :type, :attributes
+
+    def initialize(bot, key, type, attributes, block = nil)
+      @bot = bot
+      @key = key
+      @type = type
+      @attributes = attributes
+      @block = block
+    end
+
+    def match(event)
+      dummy_handler = @bot.handler_class(@type).new(@attributes, @bot)
+      return [nil, nil] unless dummy_handler.matches?(event)
+
+      should_delete = true if (@block && @block.call(event) != false) || !@block
+
+      [@key, should_delete]
+    end
+  end
+end

data/lib/discordrb/bot.rb

@@ -10,15 +10,17 @@ require 'discordrb/events/voice_state_update'
 require 'discordrb/events/channel_create'
 require 'discordrb/events/channel_update'
 require 'discordrb/events/channel_delete'
-require 'discordrb/events/guild_member_update'
+require 'discordrb/events/members'
 require 'discordrb/events/guild_role_create'
 require 'discordrb/events/guild_role_delete'
 require 'discordrb/events/guild_role_update'
+require 'discordrb/events/await'
 
 require 'discordrb/api'
 require 'discordrb/games'
 require 'discordrb/exceptions'
 require 'discordrb/data'
+require 'discordrb/await'
 
 module Discordrb
   # Represents a Discord bot, including servers, users, etc.
@@ -45,6 +47,8 @@ module Discordrb
 
       @channels = {}
       @users = {}
+
+      @awaits = {}
     end
 
     def run(async = false)
@@ -121,6 +125,27 @@ module Discordrb
       @servers[id]
     end
 
+    def find(channel_name, server_name = nil, threshold = 0)
+      require 'levenshtein'
+
+      results = []
+      @servers.values.each do |server|
+        server.channels.each do |channel|
+          distance = Levenshtein.distance(channel.name, channel_name)
+          distance += Levenshtein.distance(server_name || server.name, server.name)
+          next if distance > threshold
+
+          # Make a singleton accessor "distance"
+          channel.instance_variable_set(:@distance, distance)
+          class << channel
+            attr_reader :distance
+          end
+          results << channel
+        end
+      end
+      results
+    end
+
     def send_message(channel_id, content)
       debug("Sending message to #{channel_id} with content '#{content}'")
       response = API.send_message(@token, channel_id, content)
@@ -131,6 +156,18 @@ module Discordrb
       API.send_file(@token, channel_id, file)
     end
 
+    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
+
+    def parse_mention(mention)
+      # Mention format: <@id>
+      return nil unless /\<@(?<id>\d+)\>?/ =~ mention
+      user(id)
+    end
+
     def game=(name_or_id)
       game = Discordrb::Games.find_game(name_or_id)
       @game = game
@@ -149,6 +186,14 @@ module Discordrb
 
     attr_writer :debug
 
+    ##     ##    ###    ##    ## ########  ##       ######## ########   ######
+    ##     ##   ## ##   ###   ## ##     ## ##       ##       ##     ## ##    ##
+    ##     ##  ##   ##  ####  ## ##     ## ##       ##       ##     ## ##
+    ######### ##     ## ## ## ## ##     ## ##       ######   ########   ######
+    ##     ## ######### ##  #### ##     ## ##       ##       ##   ##         ##
+    ##     ## ##     ## ##   ### ##     ## ##       ##       ##    ##  ##    ##
+    ##     ## ##     ## ##    ## ########  ######## ######## ##     ##  ######
+
     def message(attributes = {}, &block)
       register_event(MessageEvent, attributes, block)
     end
@@ -210,6 +255,22 @@ module Discordrb
       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 await(attributes = {}, &block)
+      register_event(AwaitEvent, attributes, block)
+    end
+
     def remove_handler(handler)
       clazz = event_class(handler.class)
       @event_handlers[clazz].delete(handler)
@@ -224,10 +285,22 @@ module Discordrb
       puts "[DEBUG @ #{Time.now}] #{message}" if @debug || important
     end
 
+    def handler_class(event_class)
+      class_from_string(event_class.to_s + 'Handler')
+    end
+
     alias_method :<<, :add_handler
 
     private
 
+    ### ##    ## ######## ######## ########  ##    ##    ###    ##        ######
+    ##  ###   ##    ##    ##       ##     ## ###   ##   ## ##   ##       ##    ##
+    ##  ####  ##    ##    ##       ##     ## ####  ##  ##   ##  ##       ##
+    ##  ## ## ##    ##    ######   ########  ## ## ## ##     ## ##        ######
+    ##  ##  ####    ##    ##       ##   ##   ##  #### ######### ##             ##
+    ##  ##   ###    ##    ##       ##    ##  ##   ### ##     ## ##       ##    ##
+    ### ##    ##    ##    ######## ##     ## ##    ## ##     ## ########  ######
+
     # Internal handler for PRESENCE_UPDATE
     def update_presence(data)
       user_id = data['user']['id'].to_i
@@ -295,21 +368,57 @@ module Discordrb
       server.channels.reject! { |c| c.id == channel.id }
     end
 
+    # Internal handler for GUILD_MEMBER_ADD
+    def add_guild_member(data)
+      user = User.new(data['user'], self)
+      server_id = data['guild_id'].to_i
+      server = @servers[server_id]
+
+      roles = []
+      data['roles'].each do |element|
+        role_id = element.to_i
+        roles << server.roles.find { |r| r.id == role_id }
+      end
+      user.update_roles(server, roles)
+
+      if @users[user.id]
+        # If the user is already cached, just add the new roles
+        @users[user.id].merge_roles(server, user.roles[server.id])
+      else
+        @users[user.id] = user
+      end
+
+      server.add_user(user)
+    end
+
     # Internal handler for GUILD_MEMBER_UPDATE
     def update_guild_member(data)
-      user_data = data['user']
+      user_id = data['user']['id'].to_i
+      user = @users[user_id]
+
       server_id = data['guild_id'].to_i
       server = @servers[server_id]
+
       roles = []
       data['roles'].each do |element|
         role_id = element.to_i
         roles << server.roles.find { |r| r.id == role_id }
       end
-      user_id = user_data['id'].to_i
-      user = @users[user_id]
       user.update_roles(server, roles)
     end
 
+    # Internal handler for GUILD_MEMBER_DELETE
+    def delete_guild_member(data)
+      user_id = data['user']['id'].to_i
+      user = @users[user_id]
+
+      server_id = data['guild_id'].to_i
+      server = @servers[server_id]
+
+      user.delete_roles(server_id)
+      server.delete_user(user_id)
+    end
+
     # Internal handler for GUILD_ROLE_UPDATE
     def update_guild_role(data)
       role_data = data['role']
@@ -345,6 +454,14 @@ module Discordrb
     # Internal handler for TYPING_START
     def start_typing(data); end
 
+    ##        #######   ######   #### ##    ##
+    ##       ##     ## ##    ##   ##  ###   ##
+    ##       ##     ## ##         ##  ####  ##
+    ##       ##     ## ##   ####  ##  ## ## ##
+    ##       ##     ## ##    ##   ##  ##  ####
+    ##       ##     ## ##    ##   ##  ##   ###
+    ########  #######   ######   #### ##    ##
+
     def login
       debug('Logging in')
       login_attempts ||= 0
@@ -382,6 +499,14 @@ module Discordrb
       JSON.parse(response)['url']
     end
 
+    ##      ##  ######     ######## ##     ## ######## ##    ## ########  ######
+    ##  ##  ## ##    ##    ##       ##     ## ##       ###   ##    ##    ##    ##
+    ##  ##  ## ##          ##       ##     ## ##       ####  ##    ##    ##
+    ##  ##  ##  ######     ######   ##     ## ######   ## ## ##    ##     ######
+    ##  ##  ##       ##    ##        ##   ##  ##       ##  ####    ##          ##
+    ##  ##  ## ##    ##    ##         ## ##   ##       ##   ###    ##    ##    ##
+    ####  ###   ######     ########    ###    ######## ##    ##    ##     ######
+
     def websocket_connect
       debug('Attempting to get gateway URL...')
       websocket_hub = find_gateway
@@ -493,11 +618,21 @@ module Discordrb
 
         event = ChannelDeleteEvent.new(data, self)
         raise_event(event)
+      when 'GUILD_MEMBER_ADD'
+        add_guild_member(data)
+
+        event = GuildMemberAddEvent.new(data, self)
+        raise_event(event)
       when 'GUILD_MEMBER_UPDATE'
         update_guild_member(data)
 
         event = GuildMemberUpdateEvent.new(data, self)
         raise_event(event)
+      when 'GUILD_MEMBER_REMOVE'
+        delete_guild_member(data)
+
+        event = GuildMemberDeleteEvent.new(data, self)
+        raise_event(event)
       when 'GUILD_ROLE_UPDATE'
         update_guild_role(data)
 
@@ -549,12 +684,26 @@ module Discordrb
 
     def raise_event(event)
       debug("Raised a #{event.class}")
+      handle_awaits(event)
+
       handlers = @event_handlers[event.class]
       (handlers || []).each do |handler|
         handler.match(event)
       end
     end
 
+    def handle_awaits(event)
+      @awaits.each do |_, await|
+        key, should_delete = await.match(event)
+        next unless key
+        debug("should_delete: #{should_delete}")
+        @awaits.delete(await.key) if should_delete
+
+        await_event = Discordrb::Events::AwaitEvent.new(await, event, self)
+        raise_event(await_event)
+      end
+    end
+
     def register_event(clazz, attributes, block)
       handler = handler_class(clazz).new(attributes, block)
 
@@ -588,9 +737,5 @@ module Discordrb
 
       class_from_string(class_name[0..-8])
     end
-
-    def handler_class(event_class)
-      class_from_string(event_class.to_s + 'Handler')
-    end
   end
 end

data/lib/discordrb/commands/command_bot.rb

@@ -91,7 +91,7 @@ module Discordrb::Commands
         event.respond @attributes[:command_doesnt_exist_message].gsub('%command%', name) if @attributes[:command_doesnt_exist_message]
         return
       end
-      if permission?(user(event.user.id), command.attributes[:permission_level], event.server.id)
+      if permission?(user(event.user.id), command.attributes[:permission_level], event.server)
         event.command = command
         command.call(event, arguments, chained)
       else
@@ -132,8 +132,8 @@ module Discordrb::Commands
       @permissions[:roles][id] = level
     end
 
-    def permission?(user, level, server_id)
-      determined_level = user.roles[server_id].each.reduce(0) do |memo, role|
+    def permission?(user, level, server)
+      determined_level = server.nil? ? 0 : 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

data/lib/discordrb/data.rb

@@ -8,20 +8,12 @@ require 'discordrb/games'
 module Discordrb
   # User on Discord, including internal data like discriminators
   class User
-    attr_reader :username, :id, :discriminator, :avatar
+    attr_reader :username, :id, :discriminator, :avatar, :voice_channel, :roles
+    attr_accessor :status, :game, :server_mute, :server_deaf, :self_mute, :self_deaf
 
-    attr_accessor :status
-    attr_accessor :game
-    attr_accessor :server_mute
-    attr_accessor :server_deaf
-    attr_accessor :self_mute
-    attr_accessor :self_deaf
-    attr_reader :voice_channel
-
-    # Hash of user roles.
+    # @roles is a hash of user roles:
     # Key: Server ID
     # Value: Array of roles.
-    attr_reader :roles
 
     alias_method :name, :username
 
@@ -74,6 +66,16 @@ module Discordrb
       end
     end
 
+    # Delete a specific server from the roles (in case a user leaves a server)
+    def delete_roles(server_id)
+      @roles.delete(server_id)
+    end
+
+    # Add an await for a message from this user
+    def await(key, attributes = {}, &block)
+      @bot.add_await(key, MessageEvent, { from: @id }.merge(attributes), &block)
+    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).
@@ -116,11 +118,7 @@ module Discordrb
 
   # A Discord role that contains permissions and applies to certain users
   class Role
-    attr_reader :permissions
-    attr_reader :name
-    attr_reader :id
-    attr_reader :hoist
-    attr_reader :color
+    attr_reader :permissions, :name, :id, :hoist, :color
 
     def initialize(data, bot, server = nil)
       @bot = bot
@@ -142,9 +140,7 @@ module Discordrb
 
   # A Discord channel, including data like the topic
   class Channel
-    attr_reader :name, :server, :type, :id, :is_private, :recipient, :topic, :position
-
-    attr_reader :permission_overwrites
+    attr_reader :name, :server, :type, :id, :is_private, :recipient, :topic, :position, :permission_overwrites
 
     def initialize(data, bot, server = nil)
       @bot = bot
@@ -230,6 +226,11 @@ module Discordrb
       @permission_overwrites = overwrites
     end
 
+    # Add an await for a message in this channel
+    def await(key, attributes = {}, &block)
+      @bot.add_await(key, MessageEvent, { in: @id }.merge(attributes), &block)
+    end
+
     alias_method :send, :send_message
     alias_method :message, :send_message
 
@@ -272,17 +273,16 @@ module Discordrb
     def delete
       API.delete_message(@bot.token, @channel.id, @id)
     end
+
+    # Add an await for a message with the same user and channel
+    def await(key, attributes = {}, &block)
+      @bot.add_await(key, MessageEvent, { from: @author.id, in: @channel.id }.merge(attributes), &block)
+    end
   end
 
   # A server on Discord
   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
+    attr_reader :region, :name, :owner_id, :id, :members, :channels, :roles
 
     def initialize(data, bot)
       @bot = bot
@@ -370,10 +370,30 @@ module Discordrb
       end
     end
 
+    def add_user(user)
+      @members << user
+    end
+
+    def delete_user(user_id)
+      @members.reject! { |member| member.id == user_id }
+    end
+
     def create_channel(name)
       response = API.create_channel(@bot.token, @id, name, 'text')
       Channel.new(JSON.parse(response), @bot)
     end
+
+    def ban(user, message_days = 0)
+      API.ban_user(@bot.token, @id, user.id, message_days)
+    end
+
+    def unban(user)
+      API.unban_user(@bot.token, @id, user.id)
+    end
+
+    def kick(user)
+      API.kick_user(@bot.token, @id, user.id)
+    end
   end
 
   # A colour (red, green and blue values). Used for role colours

data/lib/discordrb/events/await.rb

@@ -0,0 +1,29 @@
+require 'discordrb/events/generic'
+require 'discordrb/await'
+
+module Discordrb::Events
+  # Event raised when an await is triggered
+  class AwaitEvent
+    attr_reader :await, :event
+    delegate :key, :type, :attributes, to: :await
+
+    def initialize(await, event, bot)
+      @await = await
+      @event = event
+      @bot = bot
+    end
+  end
+
+  # Event handler for AwaitEvent
+  class AwaitEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? AwaitEvent
+
+      [
+        matches_all(@attributes[:key], event.key) { |a, e| a == e },
+        matches_all(@attributes[:type], event.type) { |a, e| a == e }
+      ].reduce(true, &:&)
+    end
+  end
+end

data/lib/discordrb/events/members.rb

@@ -0,0 +1,71 @@
+require 'discordrb/events/generic'
+require 'discordrb/data'
+
+module Discordrb::Events
+  # Generic subclass for server member events (add/update/delete)
+  class GuildMemberEvent
+    attr_reader :user
+    attr_reader :roles
+    attr_reader :server
+
+    def initialize(data, bot)
+      @server = bot.server(data['guild_id'].to_i)
+      return unless @server
+
+      init_user(data, bot)
+      init_roles(data, bot)
+    end
+
+    private
+
+    def init_user(data, _)
+      user_id = data['user']['id'].to_i
+      @user = @server.members.find { |u| u.id == user_id }
+    end
+
+    def init_roles(data, _)
+      @roles = []
+      return unless data['roles']
+      data['roles'].each do |element|
+        role_id = element.to_i
+        @roles << @server.roles.find { |r| r.id == role_id }
+      end
+    end
+  end
+
+  # Generic event handler for member events
+  class GuildMemberEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? GuildMemberEvent
+
+      [
+        matches_all(@attributes[:username], event.user.name) do |a, e|
+          if a.is_a? String
+            a == e.to_s
+          else
+            a == e
+          end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Specialized subclasses
+  # Member joins
+  class GuildMemberAddEvent < GuildMemberEvent; end
+  class GuildMemberAddEventHandler < GuildMemberEventHandler; end
+
+  # Member is updated (e.g. name changed)
+  class GuildMemberUpdateEvent < GuildMemberEvent; end
+  class GuildMemberUpdateEventHandler < GuildMemberEventHandler; end
+
+  # Member leaves
+  class GuildMemberDeleteEvent < GuildMemberEvent
+    # Overide init_user to account for the deleted user on the server
+    def init_user(data, bot)
+      @user = Discordrb::User.new(data['user'], bot)
+    end
+  end
+  class GuildMemberDeleteEventHandler < GuildMemberEventHandler; end
+end

data/lib/discordrb/version.rb

@@ -1,4 +1,4 @@
 # Discordrb and all its functionality, in this case only the version.
 module Discordrb
-  VERSION = '1.3.8'
+  VERSION = '1.3.9'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: discordrb
 version: !ruby/object:Gem::Version
-  version: 1.3.8
+  version: 1.3.9
 platform: ruby
 authors:
 - meew0
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-12 00:00:00.000000000 Z
+date: 2015-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faye-websocket
@@ -102,20 +102,22 @@ files:
 - examples/pm.rb
 - lib/discordrb.rb
 - lib/discordrb/api.rb
+- lib/discordrb/await.rb
 - lib/discordrb/bot.rb
 - lib/discordrb/commands/command_bot.rb
 - lib/discordrb/commands/events.rb
 - lib/discordrb/commands/parser.rb
 - lib/discordrb/data.rb
+- lib/discordrb/events/await.rb
 - lib/discordrb/events/channel_create.rb
 - lib/discordrb/events/channel_delete.rb
 - lib/discordrb/events/channel_update.rb
 - lib/discordrb/events/generic.rb
-- lib/discordrb/events/guild_member_update.rb
 - lib/discordrb/events/guild_role_create.rb
 - lib/discordrb/events/guild_role_delete.rb
 - lib/discordrb/events/guild_role_update.rb
 - lib/discordrb/events/lifetime.rb
+- lib/discordrb/events/members.rb
 - lib/discordrb/events/message.rb
 - lib/discordrb/events/presence.rb
 - lib/discordrb/events/typing.rb

data/lib/discordrb/events/guild_member_update.rb

@@ -1,42 +0,0 @@
-require 'discordrb/events/generic'
-require 'discordrb/data'
-
-module Discordrb::Events
-  # Raised when a user updates on a server (e.g. new name)
-  class GuildMemberUpdateEvent
-    attr_reader :user
-    attr_reader :roles
-    attr_reader :server
-
-    def initialize(data, bot)
-      @server = bot.server(data['guild_id'].to_i)
-      return unless @server
-
-      user_id = data['user']['id'].to_i
-      @user = @server.members.find { |u| u.id == user_id }
-      @roles = []
-      data['roles'].each do |element|
-        role_id = element.to_i
-        @roles << @server.roles.find { |r| r.id == role_id }
-      end
-    end
-  end
-
-  # Event handler for GuildMemberUpdateEvent
-  class GuildMemberUpdateHandler < EventHandler
-    def matches?(event)
-      # Check for the proper event type
-      return false unless event.is_a? GuildMemberUpdateEvent
-
-      [
-        matches_all(@attributes[:name], event.name) do |a, e|
-          if a.is_a? String
-            a == e.to_s
-          else
-            a == e
-          end
-        end
-      ].reduce(true, &:&)
-    end
-  end
-end