rubycord 1.0.0

data/lib/rubycord/events/reactions.rb

@@ -0,0 +1,156 @@
+require "rubycord/events/generic"
+require "rubycord/data"
+
+module Rubycord::Events
+  # Generic superclass for events about adding and removing reactions
+  class ReactionEvent < Event
+    include Respondable
+
+    # @return [Emoji] the emoji that was reacted with.
+    attr_reader :emoji
+
+    # @!visibility private
+    attr_reader :message_id
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @emoji = Rubycord::Emoji.new(data["emoji"], bot, nil)
+      @user_id = data["user_id"].to_i
+      @message_id = data["message_id"].to_i
+      @channel_id = data["channel_id"].to_i
+    end
+
+    # @return [User, Member] the user that reacted to this message, or member if a server exists.
+    def user
+      # Cache the user so we don't do requests all the time
+      @user ||= if server
+        @server.member(@user_id)
+      else
+        @bot.user(@user_id)
+      end
+    end
+
+    # @return [Message] the message that was reacted to.
+    def message
+      @message ||= channel.load_message(@message_id)
+    end
+
+    # @return [Channel] the channel that was reacted in.
+    def channel
+      @channel ||= @bot.channel(@channel_id)
+    end
+
+    # @return [Server, nil] the server that was reacted in. If reacted in a PM channel, it will be nil.
+    def server
+      @server ||= channel.server
+    end
+  end
+
+  # Generic superclass for event handlers pertaining to adding and removing reactions
+  class ReactionEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ReactionEvent
+
+      [
+        matches_all(@attributes[:emoji], event.emoji) do |a, e|
+          case a
+          when Integer
+            e.id == a
+          when String
+            e.name == a || e.name == a.delete(":") || e.id == a.resolve_id
+          else
+            e == a
+          end
+        end,
+        matches_all(@attributes[:message], event.message_id) do |a, e|
+          a == e
+        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.user) do |a, e|
+          case a
+          when String
+            a == e.name
+          when :bot
+            e.current_bot?
+          else
+            a == e
+          end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Event raised when somebody reacts to a message
+  class ReactionAddEvent < ReactionEvent; end
+
+  # Event handler for {ReactionAddEvent}
+  class ReactionAddEventHandler < ReactionEventHandler; end
+
+  # Event raised when somebody removes a reaction to a message
+  class ReactionRemoveEvent < ReactionEvent; end
+
+  # Event handler for {ReactionRemoveEvent}
+  class ReactionRemoveEventHandler < ReactionEventHandler; end
+
+  # Event raised when somebody removes all reactions from a message
+  class ReactionRemoveAllEvent < Event
+    include Respondable
+
+    # @!visibility private
+    attr_reader :message_id
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @message_id = data["message_id"].to_i
+      @channel_id = data["channel_id"].to_i
+    end
+
+    # @return [Channel] the channel where the removal occurred.
+    def channel
+      @channel ||= @bot.channel(@channel_id)
+    end
+
+    # @return [Message] the message all reactions were removed from.
+    def message
+      @message ||= channel.load_message(@message_id)
+    end
+  end
+
+  # Event handler for {ReactionRemoveAllEvent}
+  class ReactionRemoveAllEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ReactionRemoveAllEvent
+
+      [
+        matches_all(@attributes[:message], event.message_id) do |a, e|
+          a == e
+        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
+      ].reduce(true, &:&)
+    end
+  end
+end

data/lib/rubycord/events/roles.rb

@@ -0,0 +1,86 @@
+require "rubycord/events/generic"
+require "rubycord/data"
+
+module Rubycord::Events
+  # Raised when a role is created on a server
+  class ServerRoleCreateEvent < Event
+    # @return [Role] the role that got created
+    attr_reader :role
+
+    # @return [Server] the server on which a role got created
+    attr_reader :server
+
+    # @!attribute [r] name
+    #   @return [String] this role's name
+    #   @see Role#name
+    delegate :name, to: :role
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @server = bot.server(data["guild_id"].to_i)
+      return unless @server
+
+      role_id = data["role"]["id"].to_i
+      @role = @server.roles.find { |r| r.id == role_id }
+    end
+  end
+
+  # Event handler for ServerRoleCreateEvent
+  class ServerRoleCreateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ServerRoleCreateEvent
+
+      [
+        matches_all(@attributes[:name], event.name) do |a, e|
+          a == if a.is_a? String
+            e.to_s
+          else
+            e
+          end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Raised when a role is deleted from a server
+  class ServerRoleDeleteEvent < Event
+    # @return [Integer] the ID of the role that got deleted.
+    attr_reader :id
+
+    # @return [Server] the server on which a role got deleted.
+    attr_reader :server
+
+    def initialize(data, bot)
+      @bot = bot
+
+      # The role should already be deleted from the server's list
+      # by the time we create this event, so we'll create a temporary
+      # role object for event consumers to use.
+      @id = data["role_id"].to_i
+      server_id = data["guild_id"].to_i
+      @server = bot.server(server_id)
+    end
+  end
+
+  # EventHandler for ServerRoleDeleteEvent
+  class ServerRoleDeleteEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ServerRoleDeleteEvent
+
+      [
+        matches_all(@attributes[:id], event.id) do |a, e|
+          a.resolve_id == e.resolve_id
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Event raised when a role updates on a server
+  class ServerRoleUpdateEvent < ServerRoleCreateEvent; end
+
+  # Event handler for ServerRoleUpdateEvent
+  class ServerRoleUpdateEventHandler < ServerRoleCreateEventHandler; end
+end

data/lib/rubycord/events/threads.rb

@@ -0,0 +1,94 @@
+module Rubycord::Events
+  # Raised when a thread is created
+  class ThreadCreateEvent < Event
+    # @return [Channel] the thread in question.
+    attr_reader :thread
+
+    delegate :name, :server, :owner, :parent_channel, :thread_metadata, to: :thread
+
+    def initialize(data, bot)
+      @bot = bot
+      @thread = data.is_a?(Rubycord::Channel) ? data : bot.channel(data["id"].to_i)
+    end
+  end
+
+  # Event handler for ChannelCreateEvent
+  class ThreadCreateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ThreadCreateEvent
+
+      [
+        matches_all(@attributes[:name], event.name) do |a, e|
+          a == if a.is_a? String
+            e.to_s
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a.resolve_id == e.resolve_id
+        end,
+        matches_all(@attributes[:invitable], event.thread.invitable) do |a, e|
+          a == e
+        end,
+        matches_all(@attributes[:owner], event.thread.owner) do |a, e|
+          a.resolve_id == e.resolve_id
+        end,
+        matches_all(@attributes[:channel], event.thread.parent) do |a, e|
+          a.resolve_id == e.resolve_id
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Raised when a thread is updated (e.g. name changes)
+  class ThreadUpdateEvent < ThreadCreateEvent; end
+
+  # Event handler for ThreadUpdateEvent
+  class ThreadUpdateEventHandler < ThreadCreateEventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ThreadUpdateEvent
+
+      super
+    end
+  end
+
+  # Raised when members are added or removed from a thread.
+  class ThreadMembersUpdateEvent < Event
+    # @return [Channel]
+    attr_reader :thread
+
+    # @return [Array<Member, User>]
+    attr_reader :added_members
+
+    # @return [Array<Integer>]
+    attr_reader :removed_member_ids
+
+    # @return [Integer]
+    attr_reader :member_count
+
+    delegate :name, :server, :owner, :parent_channel, :thread_metadata, to: :thread
+
+    def initialize(data, bot)
+      @bot = bot
+      @thread = data.is_a?(Rubycord::Channel) ? data : bot.channel(data["id"].to_i)
+      @added_members = data["added_members"]&.map do |member|
+        data["guild_id"] ? bot.member(data["guild_id"], member["user_id"]) : bot.user(member["user_id"])
+      end || []
+      @removed_member_ids = data["removed_member_ids"]&.map(&:resolve_id) || []
+      @member_count = data["member_count"]
+    end
+  end
+
+  # Event handler for ThreadMembersUpdateEvent
+  class ThreadMembersUpdateEventHandler < ThreadCreateEventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ThreadMembersUpdateEvent
+
+      super
+    end
+  end
+end

data/lib/rubycord/events/typing.rb

@@ -0,0 +1,70 @@
+require "rubycord/events/generic"
+
+module Rubycord::Events
+  # Event raised when a user starts typing
+  class TypingEvent < Event
+    include Respondable
+
+    # @return [Channel] the channel on which a user started typing.
+    attr_reader :channel
+
+    # @return [User, Member, Recipient] the user that started typing.
+    attr_reader :user
+    alias_method :member, :user
+
+    # @return [Time] when the typing happened.
+    attr_reader :timestamp
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @user_id = data["user_id"].to_i
+
+      @channel_id = data["channel_id"].to_i
+      @channel = bot.channel(@channel_id)
+
+      @user = if channel.pm?
+        channel.recipient
+      elsif channel.group?
+        bot.user(@user_id)
+      else
+        bot.member(@channel.server.id, @user_id)
+      end
+
+      @timestamp = Time.at(data["timestamp"].to_i)
+    end
+  end
+
+  # Event handler for TypingEvent
+  class TypingEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? TypingEvent
+
+      [
+        matches_all(@attributes[:in], event.channel) do |a, e|
+          case a
+          when String
+            a.delete("#") == e.name
+          when Integer
+            a == e.id
+          else
+            a == e
+          end
+        end,
+        matches_all(@attributes[:from], event.user) do |a, e|
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:after], event.timestamp) { |a, e| a > e },
+        matches_all(@attributes[:before], event.timestamp) { |a, e| a < e }
+      ].reduce(true, &:&)
+    end
+  end
+end

data/lib/rubycord/events/voice_server_update.rb

@@ -0,0 +1,45 @@
+require "rubycord/events/generic"
+require "rubycord/data"
+
+module Rubycord::Events
+  # Event raised when a server's voice server is updating.
+  # Sent when initially connecting to voice and when a voice instance fails
+  # over to a new server.
+  # This event is exposed for use with library agnostic interfaces like telecom and
+  # lavalink.
+  class VoiceServerUpdateEvent < Event
+    # @return [String] The voice connection token
+    attr_reader :token
+
+    # @return [Server] The server this update is for.
+    attr_reader :server
+
+    # @return [String] The voice server host.
+    attr_reader :endpoint
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @token = data["token"]
+      @endpoint = data["endpoint"]
+      @server = bot.server(data["guild_id"])
+    end
+  end
+
+  # Event handler for VoiceServerUpdateEvent
+  class VoiceServerUpdateEventHandler < EventHandler
+    def matches?(event)
+      return false unless event.is_a? VoiceServerUpdateEvent
+
+      [
+        matches_all(@attributes[:from], event.server) do |a, e|
+          a == if a.is_a? String
+            e.name
+          else
+            e
+          end
+        end
+      ]
+    end
+  end
+end

data/lib/rubycord/events/voice_state_update.rb

@@ -0,0 +1,103 @@
+require "rubycord/events/generic"
+require "rubycord/data"
+
+module Rubycord::Events
+  # Event raised when a user's voice state updates
+  class VoiceStateUpdateEvent < Event
+    attr_reader :user, :token, :suppress, :session_id, :self_mute, :self_deaf, :mute, :deaf, :server, :channel
+
+    # @return [Channel, nil] the old channel this user was on, or nil if the user is newly joining voice.
+    attr_reader :old_channel
+
+    def initialize(data, old_channel_id, bot)
+      @bot = bot
+
+      @token = data["token"]
+      @suppress = data["suppress"]
+      @session_id = data["session_id"]
+      @self_mute = data["self_mute"]
+      @self_deaf = data["self_deaf"]
+      @mute = data["mute"]
+      @deaf = data["deaf"]
+      @server = bot.server(data["guild_id"].to_i)
+      return unless @server
+
+      @channel = bot.channel(data["channel_id"].to_i) if data["channel_id"]
+      @old_channel = bot.channel(old_channel_id) if old_channel_id
+      @user = bot.user(data["user_id"].to_i)
+    end
+  end
+
+  # Event handler for VoiceStateUpdateEvent
+  class VoiceStateUpdateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? VoiceStateUpdateEvent
+
+      [
+        matches_all(@attributes[:from], event.user) do |a, e|
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:mute], event.mute) do |a, e|
+          a == if a.is_a? String
+            e.to_s
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:deaf], event.deaf) do |a, e|
+          a == if a.is_a? String
+            e.to_s
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:self_mute], event.self_mute) do |a, e|
+          a == if a.is_a? String
+            e.to_s
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:self_deaf], event.self_deaf) do |a, e|
+          a == if a.is_a? String
+            e.to_s
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:channel], event.channel) do |a, e|
+          next unless e # Don't bother if the channel is nil
+
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:old_channel], event.old_channel) do |a, e|
+          next unless e # Don't bother if the channel is nil
+
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+end

data/lib/rubycord/events/webhooks.rb

@@ -0,0 +1,62 @@
+require "rubycord/events/generic"
+require "rubycord/data"
+
+module Rubycord::Events
+  # Event raised when a webhook is updated
+  class WebhookUpdateEvent < Event
+    # @return [Server] the server where the webhook updated
+    attr_reader :server
+
+    # @return [Channel] the channel the webhook is associated to
+    attr_reader :channel
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @server = bot.server(data["guild_id"].to_i)
+      @channel = bot.channel(data["channel_id"].to_i)
+    end
+  end
+
+  # Event handler for {WebhookUpdateEvent}
+  class WebhookUpdateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? WebhookUpdateEvent
+
+      [
+        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|
+          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[:webhook], event) do |a, e|
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+end