onyxcord 1.1.0

data/lib/onyxcord/events/invites.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module OnyxCord::Events
+  # Raised when an invite is created.
+  class InviteCreateEvent < Event
+    # @return [Invite] The invite that was created.
+    attr_reader :invite
+
+    # @return [Server, nil] The server the invite was created for.
+    attr_reader :server
+
+    # @return [Channel] The channel the invite was created for.
+    attr_reader :channel
+
+    # @!attribute [r] code
+    #   @return [String] The code for the created invite.
+    #   @see Invite#code
+    # @!attribute [r] created_at
+    #   @return [Time] The time the invite was created at.
+    #   @see Invite#created_at
+    # @!attribute [r] max_age
+    #   @return [Integer] The maximum age of the created invite.
+    #   @see Invite#max_age
+    # @!attribute [r] max_uses
+    #   @return [Integer] The maximum number of uses before the invite expires.
+    #   @see Invite#max_uses
+    # @!attribute [r] temporary
+    #   @return [true, false] Whether or not this invite grants temporary membership.
+    #   @see Invite#temporary
+    # @!attribute [r] inviter
+    #   @return [User] The user that created the invite.
+    #   @see Invite#inviter
+    delegate :code, :created_at, :max_age, :max_uses, :temporary, :inviter, to: :invite
+
+    alias temporary? temporary
+
+    # @!visibility private
+    def initialize(data, invite, bot)
+      @bot = bot
+      @invite = invite
+      @channel = bot.channel(data['channel_id'])
+      @server = bot.server(data['guild_id']) if data['guild_id']
+    end
+  end
+
+  # Raised when an invite is deleted.
+  class InviteDeleteEvent < Event
+    # @return [Channel] The channel the deleted invite was for.
+    attr_reader :channel
+
+    # @return [Server, nil] The server the deleted invite was for.
+    attr_reader :server
+
+    # @return [String] The code of the deleted invite.
+    attr_reader :code
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @channel = bot.channel(data['channel_id'])
+      @server = bot.server(data['guild_id']) if data['guild_id']
+      @code = data['code']
+    end
+  end
+
+  # Event handler for InviteCreateEvent.
+  class InviteCreateEventHandler < EventHandler
+    def matches?(event)
+      return false unless event.is_a? InviteCreateEvent
+
+      [
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a == case a
+               when String
+                 e.name
+               when Integer
+                 e.id
+               else
+                 e
+               end
+        end,
+        matches_all(@attributes[:channel], event.channel) do |a, e|
+          a == case a
+               when String
+                 e.name
+               when Integer
+                 e.id
+               else
+                 e
+               end
+        end,
+        matches_all(@attributes[:temporary], event.temporary?, &:==),
+        matches_all(@attributes[:inviter], event.inviter, &:==)
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Event handler for InviteDeleteEvent
+  class InviteDeleteEventHandler < EventHandler
+    def matches?(event)
+      return false unless event.is_a? InviteDeleteEvent
+
+      [
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a == case a
+               when String
+                 e.name
+               when Integer
+                 e.id
+               else
+                 e
+               end
+        end,
+        matches_all(@attributes[:channel], event.channel) do |a, e|
+          a == case a
+               when String
+                 e.name
+               when Integer
+                 e.id
+               else
+                 e
+               end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+end

data/lib/onyxcord/events/lifetime.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+
+module OnyxCord::Events
+  # Common superclass for all lifetime events
+  class LifetimeEvent < Event
+    # @!visibility private
+    def initialize(bot)
+      @bot = bot
+    end
+  end
+
+  # @see OnyxCord::EventContainer#ready
+  class ReadyEvent < LifetimeEvent; end
+
+  # Event handler for {ReadyEvent}
+  class ReadyEventHandler < TrueEventHandler; end
+
+  # @see OnyxCord::EventContainer#disconnected
+  class DisconnectEvent < LifetimeEvent; end
+
+  # Event handler for {DisconnectEvent}
+  class DisconnectEventHandler < TrueEventHandler; end
+
+  # @see OnyxCord::EventContainer#heartbeat
+  class HeartbeatEvent < LifetimeEvent; end
+
+  # Event handler for {HeartbeatEvent}
+  class HeartbeatEventHandler < TrueEventHandler; end
+end

data/lib/onyxcord/events/members.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+require 'onyxcord/data'
+
+module OnyxCord::Events
+  # Generic subclass for server member events (add/update/delete)
+  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
+
+    # @return [Server] the server on which the event happened.
+    attr_reader :server
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+
+      @server = bot.server(data['guild_id'].to_i)
+      return unless @server
+
+      init_user(data, bot)
+      init_roles(data, bot)
+    end
+
+    private
+
+    # @!visibility private
+    def init_user(data, _)
+      user_id = data['user']['id'].to_i
+      @user = @server.member(user_id)
+    end
+
+    # @!visibility private
+    def init_roles(data, _)
+      @roles = [@server.role(@server.id)]
+      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 ServerMemberEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ServerMemberEvent
+
+      [
+        matches_all(@attributes[:username], event.user.name) do |a, e|
+          a == if a.is_a? String
+                 e.to_s
+               else
+                 e
+               end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Member joins
+  # @see OnyxCord::EventContainer#member_join
+  class ServerMemberAddEvent < ServerMemberEvent; end
+
+  # Event handler for {ServerMemberAddEvent}
+  class ServerMemberAddEventHandler < ServerMemberEventHandler; end
+
+  # Member is updated (roles added or deleted)
+  # @see OnyxCord::EventContainer#member_update
+  class ServerMemberUpdateEvent < ServerMemberEvent
+    # @!visibility private
+    # @note Override init_user so we don't make requests all the time on large servers
+    def init_user(data, _)
+      @user_id = data['user']['id']
+    end
+
+    # @return [Member] the member in question.
+    def user
+      @server&.member(@user_id)
+    end
+
+    alias_method :member, :user
+  end
+
+  # Event handler for {ServerMemberUpdateEvent}
+  class ServerMemberUpdateEventHandler < ServerMemberEventHandler; end
+
+  # Member leaves
+  # @see OnyxCord::EventContainer#member_leave
+  class ServerMemberDeleteEvent < ServerMemberEvent
+    # @!visibility private
+    # @note Override init_user to account for the deleted user on the server
+    def init_user(data, bot)
+      @user = OnyxCord::User.new(data['user'], bot)
+    end
+
+    # @return [User] the user in question.
+    attr_reader :user
+  end
+
+  # Event handler for {ServerMemberDeleteEvent}
+  class ServerMemberDeleteEventHandler < ServerMemberEventHandler; end
+end

data/lib/onyxcord/events/message.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+require 'onyxcord/data'
+
+module OnyxCord::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 occurred
+    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
+    # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
+    # @param embed [Hash, OnyxCord::Webhooks::Embed, nil] The rich embed to append to this message.
+    # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
+    # @param allowed_mentions [Hash, OnyxCord::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
+    # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
+    # @param components [View, Array<Hash>, nil] A collection of components to attach to the message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2), SUPPRESS_NOTIFICATIONS (1 << 12), and IS_COMPONENTS_V2 (1 << 15) can be set.
+    # @return [OnyxCord::Message] the message that was sent
+    def send_message(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0)
+      channel.send_message(content, tts, embed, attachments, allowed_mentions, message_reference, components, flags)
+    end
+
+    # The same as {#send_message}, but yields a {Webhooks::Embed} for easy building of embedded content inside a block.
+    # @see Channel#send_embed
+    # @param message [String] The message that should be sent along with the embed. If this is the empty string, only the embed will be shown.
+    # @param embed [OnyxCord::Webhooks::Embed, nil] The embed to start the building process with, or nil if one should be created anew.
+    # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
+    # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
+    # @param allowed_mentions [Hash, OnyxCord::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
+    # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
+    # @param components [View, Array<Hash>, nil] A collection of components to attach to the message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2), SUPPRESS_NOTIFICATIONS (1 << 12), and IS_COMPONENTS_V2 (1 << 15) can be set.
+    # @yield [embed] Yields the embed to allow for easy building inside a block.
+    # @yieldparam embed [OnyxCord::Webhooks::Embed] The embed from the parameters, or a new one.
+    # @return [Message] The resulting message.
+    def send_embed(message = '', embed = nil, attachments = nil, tts = false, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, &block)
+      channel.send_embed(message, embed, attachments, tts, allowed_mentions, message_reference, components, flags, &block)
+    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.
+    # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
+    # @param embed [Hash, OnyxCord::Webhooks::Embed, nil] The rich embed to append to this message.
+    # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
+    # @param allowed_mentions [Hash, OnyxCord::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
+    # @param components [View, Array<Hash>, nil] A collection of components to attach to the message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2), SUPPRESS_NOTIFICATIONS (1 << 12), and IS_COMPONENTS_V2 (1 << 15) can be set.
+    def send_temporary_message(content, timeout, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, components = nil, flags = 0)
+      channel.send_temporary_message(content, timeout, tts, embed, attachments, allowed_mentions, components, flags)
+    end
+
+    # Sends a message to the channel this message was sent in, right now.
+    # @see Channel#send_message!
+    def send_message!(...)
+      channel.send_message!(...)
+    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?(OnyxCord::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
+
+    alias_method :send!, :send_message!
+    alias_method :respond!, :send_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 has been saved by a call to {#attach_file} and will be sent to Discord upon completion.
+    attr_reader :file
+
+    # @return [String] the filename set in {#attach_file} that will override the original filename when sent.
+    attr_reader :filename
+
+    # @return [true, false] Whether or not this file should appear as a spoiler. Set by {#attach_file}
+    attr_reader :file_spoiler
+
+    # @!attribute [r] author
+    #   @return [Member, User] who sent this message.
+    #   @see Message#author
+    # @!attribute [r] channel
+    #   @return [Channel] the channel in which this message was sent.
+    #   @see Message#channel
+    # @!attribute [r] content
+    #   @return [String] the message's content.
+    #   @see Message#content
+    # @!attribute [r] timestamp
+    #   @return [Time] the time at which the message was sent.
+    #   @see Message#timestamp
+    delegate :author, :channel, :content, :timestamp, to: :message
+
+    # @!attribute [r] server
+    #   @return [Server, nil] the server where this message was sent, or nil if it was sent in PM.
+    #   @see Channel#server
+    delegate :server, to: :channel
+
+    # @!visibility private
+    def initialize(message, bot)
+      @bot = bot
+      @message = message
+      @channel = message.channel
+      @saved_message = ''
+      @file = nil
+      @filename = nil
+      @file_spoiler = nil
+    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
+    # @param filename [String] Overrides the filename of the uploaded file
+    # @param spoiler [true, false] Whether or not this file should appear as a spoiler.
+    # @return [OnyxCord::Message] the message that was sent
+    # @example Send a file from disk
+    #   event.send_file(File.open('rubytaco.png', 'r'))
+    def send_file(file, caption: nil, filename: nil, spoiler: nil)
+      @message.channel.send_file(file, caption: caption, filename: filename, spoiler: spoiler)
+    end
+
+    # Attaches a file to the message event and converts the message into
+    # a caption.
+    # @param file [File] The file to be attached
+    # @param filename [String] Overrides the filename of the uploaded file
+    # @param spoiler [true, false] Whether or not this file should appear as a spoiler.
+    def attach_file(file, filename: nil, spoiler: nil)
+      raise ArgumentError, 'Argument is not a file!' unless file.is_a?(File)
+
+      @file = file
+      @filename = filename
+      @file_spoiler = spoiler
+      nil
+    end
+
+    # Detaches a file from the message event.
+    def detach_file
+      @file = nil
+      @filename = nil
+      @file_spoiler = 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
+    end
+
+    # Utility method to get the voice bot for the current server
+    # @return [VoiceBot, nil] the voice bot connected to this message's server, or nil if there is none connected
+    def voice
+      @bot.voice(@message.channel.server.id)
+    end
+
+    alias_method :user, :author
+    alias_method :text, :content
+  end
+
+  # Event handler for MessageEvent
+  class MessageEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? MessageEvent
+
+      [
+        matches_all(@attributes[:starting_with] || @attributes[:start_with], event.content) do |a, e|
+          case a
+          when String
+            e.start_with? a
+          when Regexp
+            (e =~ a)&.zero?
+          end
+        end,
+        matches_all(@attributes[:ending_with] || @attributes[:end_with], event.content) do |a, e|
+          case a
+          when String
+            e.end_with? a
+          when Regexp
+            !(e =~ Regexp.new("#{a}$")).nil?
+          end
+        end,
+        matches_all(@attributes[:containing] || @attributes[:contains], event.content) do |a, e|
+          case a
+          when String
+            e.include? a
+          when Regexp
+            (e =~ a)
+          end
+        end,
+        matches_all(@attributes[:in], event.channel) do |a, e|
+          case a
+          when String
+            # Make sure to remove the "#" from channel names in case it was specified
+            a.delete('#') == e.name
+          when Integer
+            a == e.id
+          else
+            a == e
+          end
+        end,
+        matches_all(@attributes[:from], event.message) do |a, e|
+          # Resolve the author in the block in order to prevent resolving the author even when the attribute is `nil`
+          e = e.author
+          case a
+          when String
+            a == e.name
+          when Integer
+            a == e.id
+          when :bot
+            e.current_bot?
+          else
+            a == e
+          end
+        end,
+        matches_all(@attributes[:with_text] || @attributes[:content] || @attributes[:exact_text], event.content) do |a, e|
+          case a
+          when String
+            e == a
+          when Regexp
+            match = a.match(e)
+            match ? (e == match[0]) : false
+          end
+        end,
+        matches_all(@attributes[:type] || @attributes[:message_type], event.message.type) do |a, e|
+          case a
+          when String, Symbol
+            OnyxCord::Message::TYPES[a.to_sym] == e
+          when Integer
+            a == e
+          end
+        end,
+        matches_all(@attributes[:after], event.timestamp) { |a, e| a > e },
+        matches_all(@attributes[:before], event.timestamp) { |a, e| a < e },
+        matches_all(@attributes[:private], event.channel.private?) { |a, e| !e == !a },
+        matches_all(@attributes[:server], event.server) { |a, e| a&.resolve_id == e&.resolve_id }
+      ].reduce(true, &:&)
+    end
+
+    # @see EventHandler#after_call
+    def after_call(event)
+      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, filename: event.filename, spoiler: event.file_spoiler)
+      end
+    end
+  end
+
+  # Event raised when the current bot is mentioned in a message.
+  class MentionEvent < MessageEvent
+    # @return [true, false] whether this mention event was raised
+    #   due to a mention of the bot's auto-generated server role.
+    attr_reader :role_mention
+    alias_method :role_mention?, :role_mention
+
+    # @!visibility private
+    def initialize(message, bot, role_mention)
+      super(message, bot)
+
+      @role_mention = role_mention
+    end
+  end
+
+  # Event handler for {MentionEvent}
+  class MentionEventHandler < MessageEventHandler
+    # @!visibility private
+    def matches?(event)
+      return false unless super
+      return false unless event.is_a?(MentionEvent)
+
+      [
+        matches_all(@attributes[:role_mention], event.role_mention) do |a, e|
+          case a
+          when TrueClass
+            e == true
+          when FalseClass
+            e == false
+          end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # @see OnyxCord::EventContainer#pm
+  class PrivateMessageEvent < MessageEvent; end
+
+  # Event handler for {PrivateMessageEvent}
+  class PrivateMessageEventHandler < MessageEventHandler; end
+
+  # 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 [Server, nil] the server associated with this event
+    attr_reader :server
+
+    # @!visibility private
+    def initialize(data, bot)
+      @id = data['id'].to_i
+      @channel = bot.channel(data['channel_id'].to_i)
+      @server = @channel.server
+      @saved_message = ''
+      @bot = bot
+    end
+  end
+
+  # Event handler for {MessageIDEvent}
+  class MessageIDEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? MessageIDEvent
+
+      [
+        matches_all(@attributes[:id], event.id) do |a, e|
+          a.resolve_id == e.resolve_id
+        end,
+        matches_all(@attributes[:in], event.channel) do |a, e|
+          case a
+          when String
+            # Make sure to remove the "#" from channel names in case it was specified
+            a.delete('#') == e.name
+          when Integer
+            a == e.id
+          else
+            a == e
+          end
+        end,
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a&.resolve_id == e&.resolve_id
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Raised when a message is edited
+  # @see OnyxCord::EventContainer#message_edit
+  class MessageEditEvent < MessageEvent; end
+
+  # Event handler for {MessageEditEvent}
+  class MessageEditEventHandler < MessageEventHandler; end
+
+  # Raised when a message is deleted
+  # @see OnyxCord::EventContainer#message_delete
+  class MessageDeleteEvent < MessageIDEvent; end
+
+  # Event handler for {MessageDeleteEvent}
+  class MessageDeleteEventHandler < MessageIDEventHandler; end
+
+  # Raised whenever a MESSAGE_UPDATE is received
+  # @see OnyxCord::EventContainer#message_update
+  class MessageUpdateEvent < MessageEvent; end
+
+  # Event handler for {MessageUpdateEvent}
+  class MessageUpdateEventHandler < MessageEventHandler; end
+end