discordrb 2.1.3 → 3.0.0

data/lib/discordrb/errors.rb

@@ -19,5 +19,150 @@ module Discordrb
 
     # Raised when the bot gets a HTTP 502 error, which is usually caused by Cloudflare.
     class CloudflareError < RuntimeError; end
+
+    # Generic class for errors denoted by API error codes
+    class CodeError < RuntimeError
+      class << self
+        # @return [Integer] The error code represented by this error class.
+        attr_reader :code
+      end
+
+      # Create a new error with a particular message (the code should be defined by the class instance variable)
+      # @param message [String] the message to use
+      def initialize(message)
+        @message = message
+      end
+
+      # @return [Integer] The error code represented by this error.
+      def code
+        self.class.code
+      end
+
+      # @return [String] This error's represented message
+      attr_reader :message
+    end
+
+    # Create a new code error class
+    # rubocop:disable Style/MethodName
+    def self.Code(code)
+      classy = Class.new(CodeError)
+      classy.instance_variable_set('@code', code)
+
+      @code_classes ||= {}
+      @code_classes[code] = classy
+
+      classy
+    end
+
+    # @param code [Integer] The code to check
+    # @return [Class] the error class for the given code
+    def self.error_class_for(code)
+      @code_classes[code]
+    end
+
+    # Used when Discord doesn't provide a more specific code
+    UnknownError = Code(0)
+
+    # Unknown Account
+    UnknownAccount = Code(10_001)
+
+    # Unknown Application
+    UnknownApplication = Code(10_002)
+
+    # Unknown Channel
+    UnknownChannel = Code(10_003)
+
+    # Unknown Server
+    UnknownServer = Code(10_004)
+
+    # Unknown Integration
+    UnknownIntegration = Code(10_005)
+
+    # Unknown Invite
+    UnknownInvite = Code(10_006)
+
+    # Unknown Member
+    UnknownMember = Code(10_007)
+
+    # Unknown Message
+    UnknownMessage = Code(10_008)
+
+    # Unknown Overwrite
+    UnknownOverwrite = Code(10_009)
+
+    # Unknown Provider
+    UnknownProvider = Code(10_010)
+
+    # Unknown Role
+    UnknownRole = Code(10_011)
+
+    # Unknown Token
+    UnknownToken = Code(10_012)
+
+    # Unknown User
+    UnknownUser = Code(10_013)
+
+    # Bots cannot use this endpoint
+    EndpointNotForBots = Code(20_001)
+
+    # Only bots can use this endpoint
+    EndpointOnlyForBots = Code(20_002)
+
+    # Maximum number of servers reached (100)
+    ServerLimitReached = Code(30_001)
+
+    # Maximum number of friends reached (1000)
+    FriendLimitReached = Code(30_002)
+
+    # Unauthorized
+    Unauthorized = Unauthorised = Code(40_001)
+
+    # Missing Access
+    MissingAccess = Code(50_001)
+
+    # Invalid Account Type
+    InvalidAccountType = Code(50_002)
+
+    # Cannot execute action on a DM channel
+    InvalidForDM = Code(50_003)
+
+    # Embed Disabled
+    EmbedDisabled = Code(50_004)
+
+    # Cannot edit a message authored by another user
+    MessageAuthoredByOtherUser = Code(50_005)
+
+    # Cannot send an empty message
+    MessageEmpty = Code(50_006)
+
+    # Cannot send messages to this user
+    NoMessagesToUser = Code(50_007)
+
+    # Cannot send messages in a voice channel
+    NoMessagesInVoiceChannel = Code(50_008)
+
+    # Channel verification level is too high
+    VerificationLevelTooHigh = Code(50_009)
+
+    # OAuth2 application does not have a bot
+    NoBotForApplication = Code(50_010)
+
+    # OAuth2 application limit reached
+    ApplicationLimitReached = Code(50_011)
+
+    # Invalid OAuth State
+    InvalidOAuthState = Code(50_012)
+
+    # Missing Permissions
+    MissingPermissions = Code(50_013)
+
+    # Invalid authentication token
+    InvalidAuthToken = Code(50_014)
+
+    # Note is too long
+    NoteTooLong = Code(50_015)
+
+    # Provided too few or too many messages to delete. Must provide at least 2 and fewer than 100 messages to delete.
+    InvalidBulkDeleteCount = Code(50_016)
   end
 end

data/lib/discordrb/events/channels.rb

@@ -10,7 +10,7 @@ module Discordrb::Events
     attr_reader :channel
 
     # @!attribute [r] type
-    #   @return [String] the channel's type.
+    #   @return [Integer] the channel's type (0: text, 1: private, 2: voice, 3: group).
     #   @see Channel#type
     # @!attribute [r] topic
     #   @return [String] the channel's topic.
@@ -27,7 +27,7 @@ module Discordrb::Events
     # @!attribute [r] server
     #   @return [Server] the server the channel belongs to.
     #   @see Channel#server
-    delegate :type, :topic, :position, :name, :id, :server, to: :channel
+    delegate :name, :server, :type, :owner_id, :recipients, :topic, :user_limit, :position, :permission_overwrites, to: :channel
 
     def initialize(data, bot)
       @bot = bot
@@ -62,7 +62,7 @@ module Discordrb::Events
 
   # Raised when a channel is deleted
   class ChannelDeleteEvent < Event
-    # @return [String] the channel's type (text or voice)
+    # @return [Integer] the channel's type (0: text, 1: private, 2: voice, 3: group).
     attr_reader :type
 
     # @return [String] the channel's topic
@@ -80,6 +80,9 @@ module Discordrb::Events
     # @return [Server] the channel's server
     attr_reader :server
 
+    # @return [Integer, nil] the channel's owner ID if this is a group channel
+    attr_reader :owner_id
+
     def initialize(data, bot)
       @bot = bot
 
@@ -90,6 +93,7 @@ module Discordrb::Events
       @is_private = data['is_private']
       @id = data['id'].to_i
       @server = bot.server(data['guild_id'].to_i) if data['guild_id']
+      @owner_id = bot.user(data['owner_id']) if @type == 3
     end
   end
 
@@ -118,6 +122,62 @@ module Discordrb::Events
     end
   end
 
+  # Generic subclass for recipient events (add/remove)
+  class ChannelRecipientEvent < Event
+    # @return [Channel] the channel in question.
+    attr_reader :channel
+    delegate :name, :server, :type, :owner_id, :recipients, :topic, :user_limit, :position, :permission_overwrites, to: :channel
+
+    # @return [Recipient] the recipient that was added/removed from the group
+    attr_reader :recipient
+    delegate :id, to: :recipient
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @channel = bot.channel(data['channel_id'].to_i)
+      recipient = data['user']
+      recipient_user = bot.ensure_user(recipient)
+      @recipient = Discordrb::Recipient.new(recipient_user, @channel, bot)
+    end
+  end
+
+  # Generic event handler for channel recipient events
+  class ChannelRecipientEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ChannelRecipientEvent
+
+      [
+        matches_all(@attributes[:owner_id], event.owner_id) do |a, e|
+          a.resolve_id == e.resolve_id
+        end,
+        matches_all(@attributes[:id], event.id) do |a, e|
+          a.resolve_id == e.resolve_id
+        end,
+        matches_all(@attributes[:name], event.name) do |a, e|
+          a == if a.is_a? String
+                 e.to_s
+               else
+                 e
+               end
+        end
+      ]
+    end
+  end
+
+  # Raised when a user is added to a private channel
+  class ChannelRecipientAddEvent < ChannelRecipientEvent; end
+
+  # Event handler for ChannelRecipientAddEvent
+  class ChannelRecipientAddEventHandler < ChannelRecipientEventHandler; end
+
+  # Raised when a recipient that isn't the bot leaves or is kicked from a group channel
+  class ChannelRecipientRemoveEvent < ChannelRecipientEvent; end
+
+  # Event handler for ChannelRecipientRemoveEvent
+  class ChannelRecipientRemoveEventHandler < ChannelRecipientEventHandler; end
+
   # Raised when a channel is updated (e.g. topic changes)
   class ChannelUpdateEvent < ChannelCreateEvent; end
 

data/lib/discordrb/events/members.rb

@@ -8,6 +8,7 @@ module Discordrb::Events
   class ServerMemberEvent < Event
     # @return [Member] the member in question.
     attr_reader :user
+    alias_method :member, :user
 
     # @return [Array<Role>] the member's roles.
     attr_reader :roles
@@ -15,8 +16,6 @@ module Discordrb::Events
     # @return [Server] the server on which the event happened.
     attr_reader :server
 
-    alias_method :member, :user
-
     def initialize(data, bot)
       @bot = bot
 

data/lib/discordrb/events/message.rb

@@ -1,18 +1,78 @@
 # frozen_string_literal: true
 
 require 'discordrb/events/generic'
+require 'discordrb/data'
 
 module Discordrb::Events
+  # Module to make sending messages easier with the presence of a text channel in an event
+  module Respondable
+    # @return [Channel] the channel in which this event occured
+    attr_reader :channel
+
+    # Sends a message to the channel this message was sent in, right now. It is usually preferable to use {#<<} instead
+    # because it avoids rate limiting problems
+    # @param content [String] The message to send to the channel
+    # @return [Discordrb::Message] the message that was sent
+    def send_message(content)
+      @channel.send_message(content)
+    end
+
+    # Sends a temporary message to the channel this message was sent in, right now.
+    # @param content [String] The content to send. Should not be longer than 2000 characters or it will result in an error.
+    # @param timeout [Float] The amount of time in seconds after which the message sent will be deleted.
+    def send_temporary_message(content, timeout)
+      @channel.send_temporary_message(content, timeout)
+    end
+
+    # Adds a string to be sent after the event has finished execution. Avoids problems with rate limiting because only
+    # one message is ever sent. If it is used multiple times, the strings will bunch up into one message (separated by
+    # newlines)
+    # @param message [String] The message to send to the channel
+    def <<(message)
+      addition = "#{message}\n"
+      @saved_message = @saved_message ? @saved_message + addition : addition
+      nil
+    end
+
+    # Drains the currently saved message, which clears it out, resulting in everything being saved before being
+    # thrown away and nothing being sent to the channel (unless there is something saved after this).
+    # @see #<<
+    def drain
+      @saved_message = ''
+      nil
+    end
+
+    # Drains the currently saved message into a result string. This prepends it before that string, clears the saved
+    # message and returns the concatenation.
+    # @param result [String] The result string to drain into.
+    # @return [String] a string formed by concatenating the saved message and the argument.
+    def drain_into(result)
+      return if result.is_a?(Discordrb::Message)
+
+      result = (@saved_message.nil? ? '' : @saved_message.to_s) + (result.nil? ? '' : result.to_s)
+      drain
+      result
+    end
+
+    alias_method :send, :send_message
+    alias_method :respond, :send_message
+    alias_method :send_temp, :send_temporary_message
+  end
+
   # Event raised when a text message is sent to a channel
   class MessageEvent < Event
+    include Respondable
     # @return [Message] the message which triggered this event.
     attr_reader :message
 
     # @return [String] the message that has been saved by calls to {#<<} and will be sent to Discord upon completion.
     attr_reader :saved_message
 
+    # @return [File] the file that have been saved by calls to {#attach_file} and will be sent to Discord upon completion.
+    attr_reader :file
+
     # @!attribute [r] author
-    #   @return [User] who sent this message.
+    #   @return [Member] who sent this message.
     #   @see Message#author
     # @!attribute [r] channel
     #   @return [Channel] the channel in which this message was sent.
@@ -33,7 +93,9 @@ module Discordrb::Events
     def initialize(message, bot)
       @bot = bot
       @message = message
+      @channel = message.channel
       @saved_message = ''
+      @file = nil
     end
 
     # Sends a message to the channel this message was sent in, right now. It is usually preferable to use {#<<} instead
@@ -44,6 +106,31 @@ module Discordrb::Events
       @message.channel.send_message(content)
     end
 
+    # Sends file with a caption to the channel this message was sent in, right now.
+    # It is usually preferable to use {#<<} and {#attach_file} instead
+    # because it avoids rate limiting problems
+    # @param file [File] The file to send to the channel
+    # @param caption [String] The caption attached to the file
+    # @return [Discordrb::Message] the message that was sent
+    def send_file(file, caption: nil)
+      @message.channel.send_file(file, caption: caption)
+    end
+
+    # Attaches a file to the message event and converts the message into
+    # a caption.
+    # @param file [File] The file to be attached
+    def attach_file(file)
+      raise ArgumentError, 'Argument is not a file!' unless file.is_a?(File)
+      @file = file
+      nil
+    end
+
+    # Detaches a file from the message event.
+    def detach_file
+      @file = nil
+      nil
+    end
+
     # @return [true, false] whether or not this message was sent by the bot itself
     def from_bot?
       @message.user.id == @bot.profile.id
@@ -55,19 +142,8 @@ module Discordrb::Events
       @bot.voice(@message.channel.server.id)
     end
 
-    # Adds a string to be sent after the event has finished execution. Avoids problems with rate limiting because only
-    # one message is ever sent. If it is used multiple times, the strings will bunch up into one message (separated by
-    # newlines)
-    # @param message [String] The message to send to the channel
-    def <<(message)
-      @saved_message += "#{message}\n"
-      nil
-    end
-
     alias_method :user, :author
     alias_method :text, :content
-    alias_method :send, :send_message
-    alias_method :respond, :send_message
   end
 
   # Event handler for MessageEvent
@@ -81,7 +157,7 @@ module Discordrb::Events
           if a.is_a? String
             e.start_with? a
           elsif a.is_a? Regexp
-            (e =~ a) == 0
+            (e =~ a) && (e =~ a).zero?
           end
         end,
         matches_all(@attributes[:ending_with] || @attributes[:end_with], event.content) do |a, e|
@@ -135,7 +211,11 @@ module Discordrb::Events
 
     # @see EventHandler#after_call
     def after_call(event)
-      event.send_message(event.saved_message) unless event.saved_message.empty?
+      if event.file.nil?
+        event.send_message(event.saved_message) unless event.saved_message.empty?
+      else
+        event.send_file(event.file, caption: event.saved_message)
+      end
     end
   end
 
@@ -153,16 +233,15 @@ module Discordrb::Events
 
   # A subset of MessageEvent that only contains a message ID and a channel
   class MessageIDEvent < Event
+    include Respondable
     # @return [Integer] the ID associated with this event
     attr_reader :id
 
-    # @return [Channel] the channel in which this event occurred
-    attr_reader :channel
-
     # @!visibility private
     def initialize(data, bot)
       @id = data['id'].to_i
       @channel = bot.channel(data['channel_id'].to_i)
+      @saved_message = ''
       @bot = bot
     end
   end