onyxcord 1.1.0

data/lib/onyxcord/events/polls.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'onyxcord/data'
+require 'onyxcord/events/generic'
+
+module OnyxCord::Events
+  # Generic superclass for poll events.
+  class PollVoteEvent < Event
+    # @return [Integer] the ID of the user associated with the event.
+    attr_reader :user_id
+
+    # @return [Integer, nil] the ID of the server associated with the
+    #   event.
+    attr_reader :server_id
+
+    # @return [Integer] the ID of the answer associated with the event.
+    attr_reader :answer_id
+
+    # @return [Integer] the ID of the channel associated with the event.
+    attr_reader :channel_id
+
+    # @return [Integer] the ID of the message associated with the event.
+    attr_reader :message_id
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @user_id = data['user_id']&.to_i
+      @server_id = data['guild_id']&.to_i
+      @answer_id = data['answer_id']&.to_i
+      @channel_id = data['channel_id']&.to_i
+      @message_id = data['message_id']&.to_i
+    end
+
+    # Get the poll associated with the event.
+    # @return [Poll] The poll associated with the event.
+    def poll
+      message&.poll
+    end
+
+    # Get the poll answer associated with the event.
+    # @return [Poll::Answer] The poll answer associated with the event.
+    def answer
+      poll&.answer(@answer_id)
+    end
+
+    # Get the channel that the poll originates from.
+    # @return [Channel] The channel that the poll originates from.
+    def channel
+      @bot.channel(@channel_id)
+    end
+
+    # Get the server that the poll originates from.
+    # @return [Server, nil] The server that the poll originates from.
+    def server
+      @bot.server(@server_id) if @server_id
+    end
+
+    # Get the message that the poll originates from.
+    # @return [Message] The message that the poll originates from.
+    def message
+      @message ||= channel.load_message(@message_id)
+    end
+
+    # Get the user who added or removed their poll vote.
+    # @return [User, Member] The member who added the poll vote, or
+    #   a user if the member cannot be reached, or the poll was created
+    #   in a DM channel.
+    def user
+      @user ||= (server&.member(@user_id) || @bot.user(@user_id))
+    end
+
+    alias_method :member, :user
+  end
+
+  # Generic event handler for polls.
+  class PollVoteEventHandler < EventHandler
+    # @!visibility private
+    def matches?(event)
+      # Check for the proper event type.
+      return false unless event.is_a?(PollVoteEvent)
+
+      [
+        matches_all(@attributes[:answer], event.answer_id) do |a, e|
+          (a.respond_to?(:id) ? a.id : a&.resolve_id) == e
+        end,
+
+        matches_all(@attributes[:server], event.server_id) do |a, e|
+          a&.resolve_id == e
+        end,
+
+        matches_all(@attributes[:message], event.message_id) do |a, e|
+          a&.resolve_id == e
+        end,
+
+        matches_all(@attributes[:channel], event.channel_id) do |a, e|
+          a&.resolve_id == e
+        end,
+
+        matches_all(@attributes[:user] || @attributes[:member], event.user_id) do |a, e|
+          a&.resolve_id == e
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Raised whenever someone votes on a poll.
+  class PollVoteAddEvent < PollVoteEvent; end
+
+  # Raised whenever someone removes a poll vote.
+  class PollVoteRemoveEvent < PollVoteEvent; end
+
+  # Event handler for the :MESSAGE_POLL_VOTE_ADD event.
+  class PollVoteAddEventHandler < PollVoteEventHandler; end
+
+  # Event handler for the :MESSAGE_POLL_VOTE_REMOVE event.
+  class PollVoteRemoveEventHandler < PollVoteEventHandler; end
+end

data/lib/onyxcord/events/presence.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+require 'onyxcord/data'
+
+module OnyxCord::Events
+  # Event raised when a user's presence state updates (idle or online)
+  class PresenceEvent < Event
+    # @return [Server] the server on which the presence update happened.
+    attr_reader :server
+
+    # @return [User] the user whose status got updated.
+    attr_reader :user
+
+    # @return [Symbol] the new status.
+    attr_reader :status
+
+    # @return [Hash<Symbol, Symbol>] the current online status (`:online`, `:idle` or `:dnd`) of the user
+    #   on various device types (`:desktop`, `:mobile`, or `:web`). The value will be `nil` if the user is offline or invisible.
+    attr_reader :client_status
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+
+      @user = bot.user(data['user']['id'].to_i)
+      @status = data['status'].to_sym
+      @client_status = user.client_status
+      @server = bot.server(data['guild_id'].to_i)
+    end
+  end
+
+  # Event handler for PresenceEvent
+  class PresenceEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? PresenceEvent
+
+      [
+        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[:status], event.status) do |a, e|
+          a == if a.is_a? String
+                 e.to_s
+               else
+                 e
+               end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Event raised when a user starts or stops playing a game
+  class PlayingEvent < Event
+    # @return [Server] the server on which the presence update happened.
+    attr_reader :server
+
+    # @return [User] the user whose status got updated.
+    attr_reader :user
+
+    # @return [OnyxCord::Activity] The new activity
+    attr_reader :activity
+
+    # @!attribute [r] url
+    #   @return [String] the URL to the stream
+
+    # @!attribute [r] details
+    #   @return [String] what the player is currently doing (ex. game being streamed)
+
+    # @!attribute [r] type
+    #   @return [Integer] the type of play. See {OnyxCord::Activity}
+    delegate :url, :details, :type, to: :activity
+
+    # @return [Hash<Symbol, Symbol>] the current online status (`:online`, `:idle` or `:dnd`) of the user
+    #   on various device types (`:desktop`, `:mobile`, or `:web`). The value will be `nil` if the user is offline or invisible.
+    attr_reader :client_status
+
+    # @!visibility private
+    def initialize(data, activity, bot)
+      @bot = bot
+      @activity = activity
+
+      @server = bot.server(data['guild_id'].to_i)
+      @user = bot.user(data['user']['id'].to_i)
+      @client_status = @user.client_status
+    end
+
+    # @return [String] the name of the new game the user is playing.
+    def game
+      @activity.name
+    end
+  end
+
+  # Event handler for PlayingEvent
+  class PlayingEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? PlayingEvent
+
+      [
+        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[:game], event.game) do |a, e|
+          a == e
+        end,
+        matches_all(@attributes[:type], event.type) do |a, e|
+          a == e
+        end,
+        matches_all(@attributes[:client_status], event.client_status) do |a, e|
+          e.slice(a.keys) == a
+        end
+      ].reduce(true, &:&)
+    end
+  end
+end

data/lib/onyxcord/events/raw.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+
+# Event classes and handlers
+module OnyxCord::Events
+  # Event raised when any dispatch is received
+  class RawEvent < Event
+    # @return [Symbol] the type of this dispatch.
+    attr_reader :type
+    alias_method :t, :type
+
+    # @return [Hash] the data of this dispatch.
+    attr_reader :data
+    alias_method :d, :data
+
+    # @!visibility private
+    def initialize(type, data, bot)
+      @type = type
+      @data = data
+      @bot = bot
+    end
+  end
+
+  # Event handler for {RawEvent}
+  class RawEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? RawEvent
+
+      [
+        matches_all(@attributes[:type] || @attributes[:t], event.type) do |a, e|
+          if a.is_a? Regexp
+            a.match?(e)
+          else
+            e.to_s.casecmp(a.to_s).zero?
+          end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Event raised when an unknown dispatch is received
+  class UnknownEvent < RawEvent; end
+
+  # Event handler for {UnknownEvent}
+  class UnknownEventHandler < RawEventHandler; end
+
+  # Handler for raw Gateway payloads. This bypasses Event object allocation and
+  # receives the original parsed Gateway packet.
+  class RawDispatchHandler
+    def initialize(filter, block)
+      @filter = filter
+      @block = block
+    end
+
+    def matches?(packet)
+      return true unless @filter
+
+      type = packet['t']
+      return false unless type
+
+      if @filter.is_a?(Regexp)
+        @filter.match?(type)
+      else
+        type.to_s.casecmp(@filter.to_s).zero?
+      end
+    end
+
+    def call(packet)
+      @block.call(packet)
+    end
+  end
+end

data/lib/onyxcord/events/reactions.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+require 'onyxcord/data'
+
+module OnyxCord::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
+
+    # @return [true, false] whether the reaction is a burst reaction.
+    attr_reader :burst
+    alias_method :burst?, :burst
+
+    # @return [Integer] the type of the reaction. 0 for normal, 1 for burst.
+    attr_reader :type
+
+    # @return [Array<ColourRGB>] an array of colors used for animations in burst reactions.
+    attr_reader :burst_colours
+    alias_method :burst_colors, :burst_colours
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+
+      @emoji = OnyxCord::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
+      @burst = data['burst']
+      @type = data['type']
+      @burst_colours = data['burst_colors']&.map { |b| OnyxCord::ColourRGB.new(b.delete('#')) } || []
+    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,
+        matches_all(@attributes[:type], event.type) do |a, e|
+          case a
+          when Integer
+            a == e
+          when Symbol, String
+            OnyxCord::Reaction::TYPES[a.to_sym] == 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
+
+    # @!visibility private
+    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
+
+  # Event raised when all instances of a single reaction are removed from a message.
+  class ReactionRemoveEmojiEvent < ReactionRemoveAllEvent
+    # @return [Emoji] the emoji that was removed.
+    attr_reader :emoji
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @emoji = OnyxCord::Emoji.new(data['emoji'], bot)
+    end
+  end
+
+  # Event handler for {ReactionRemoveEmojiEvent}.
+  class ReactionRemoveEmojiEventHandler < ReactionRemoveAllEventHandler
+    # @!visibility private
+    def matches?(event)
+      # Check for the proper event type.
+      return false unless super
+      return false unless event.is_a?(ReactionRemoveEmojiEvent)
+
+      [
+        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
+      ].reduce(true, &:&)
+    end
+  end
+end

data/lib/onyxcord/events/roles.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+require 'onyxcord/data'
+
+module OnyxCord::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
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+
+      @server = bot.server(data['guild_id'].to_i)
+      @role = @server&.role(data['role']['id'].to_i)
+    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
+
+    # @!visibility private
+    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