rubycord 1.0.0

data/lib/rubycord/events/await.rb

@@ -0,0 +1,46 @@
+require "rubycord/events/generic"
+require "rubycord/await"
+
+module Rubycord::Events
+  # @see Bot#await
+  class AwaitEvent < Event
+    # The await that was triggered.
+    # @return [Await] The await
+    attr_reader :await
+
+    # The event that triggered the await.
+    # @return [Event] The event
+    attr_reader :event
+
+    # @!attribute [r] key
+    #   @return [Symbol] the await's key.
+    #   @see Await#key
+    # @!attribute [r] type
+    #   @return [Class] the await's event class.
+    #   @see Await#type
+    # @!attribute [r] attributes
+    #   @return [Hash] a hash of attributes defined on the await.
+    #   @see Await#attributes
+    delegate :key, :type, :attributes, to: :await
+
+    # For internal use only
+    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/rubycord/events/bans.rb

@@ -0,0 +1,58 @@
+require "rubycord/events/generic"
+
+module Rubycord::Events
+  # Raised when a user is banned
+  class UserBanEvent < Event
+    # @return [User] the user that was banned
+    attr_reader :user
+
+    # @return [Server] the server from which the user was banned
+    attr_reader :server
+
+    # @!visibility private
+    def initialize(data, bot)
+      @user = bot.user(data["user"]["id"].to_i)
+      @server = bot.server(data["guild_id"].to_i)
+      @bot = bot
+    end
+  end
+
+  # Event handler for {UserBanEvent}
+  class UserBanEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? UserBanEvent
+
+      [
+        matches_all(@attributes[:user], event.user) do |a, e|
+          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[:server], event.server) do |a, e|
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Raised when a user is unbanned from a server
+  class UserUnbanEvent < UserBanEvent; end
+
+  # Event handler for {UserUnbanEvent}
+  class UserUnbanEventHandler < UserBanEventHandler; end
+end

data/lib/rubycord/events/channels.rb

@@ -0,0 +1,186 @@
+require "rubycord/events/generic"
+require "rubycord/data"
+
+module Rubycord::Events
+  # Raised when a channel is created
+  class ChannelCreateEvent < Event
+    # @return [Channel] the channel in question.
+    attr_reader :channel
+
+    # @!attribute [r] 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.
+    #   @see Channel#topic
+    # @!attribute [r] position
+    #   @return [Integer] the position of the channel in the channels list.
+    #   @see Channel#position
+    # @!attribute [r] name
+    #   @return [String] the channel's name
+    #   @see Channel#name
+    # @!attribute [r] id
+    #   @return [Integer] the channel's unique ID.
+    #   @see Channel#id
+    # @!attribute [r] server
+    #   @return [Server] the server the channel belongs to.
+    #   @see Channel#server
+    delegate :name, :server, :type, :owner_id, :recipients, :topic, :user_limit, :position, :permission_overwrites, to: :channel
+
+    def initialize(data, bot)
+      @bot = bot
+      @channel = data.is_a?(Rubycord::Channel) ? data : bot.channel(data["id"].to_i)
+    end
+  end
+
+  # Event handler for ChannelCreateEvent
+  class ChannelCreateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ChannelCreateEvent
+
+      [
+        matches_all(@attributes[:type], event.type) do |a, e|
+          a == if a.is_a? String
+            e.name
+          else
+            e
+          end
+        end,
+        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 channel is deleted
+  class ChannelDeleteEvent < Event
+    # @return [Integer] the channel's type (0: text, 1: private, 2: voice, 3: group).
+    attr_reader :type
+
+    # @return [String] the channel's topic
+    attr_reader :topic
+
+    # @return [Integer] the position of the channel on the list
+    attr_reader :position
+
+    # @return [String] the channel's name
+    attr_reader :name
+
+    # @return [Integer] the channel's ID
+    attr_reader :id
+
+    # @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
+
+      @type = data["type"]
+      @topic = data["topic"]
+      @position = data["position"]
+      @name = data["name"]
+      @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
+
+  # Event handler for ChannelDeleteEvent
+  class ChannelDeleteEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ChannelDeleteEvent
+
+      [
+        matches_all(@attributes[:type], event.type) do |a, e|
+          a == if a.is_a? String
+            e.name
+          else
+            e
+          end
+        end,
+        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
+
+  # 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 = Rubycord::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
+
+  # Event handler for ChannelUpdateEvent
+  class ChannelUpdateEventHandler < ChannelCreateEventHandler; end
+end

data/lib/rubycord/events/generic.rb

@@ -0,0 +1,126 @@
+# Events used by rubycord
+module Rubycord::Events
+  # A negated object, used to not match something in event parameters.
+  # @see Rubycord::Events.matches_all
+  class Negated
+    attr_reader :object
+
+    def initialize(object)
+      @object = object
+    end
+  end
+
+  # Attempts to match possible formats of event attributes to a set comparison value, using a comparison block.
+  # It allows five kinds of attribute formats:
+  #  0. nil -> always returns true
+  #  1. A single attribute, not negated
+  #  2. A single attribute, negated
+  #  3. An array of attributes, not negated
+  #  4. An array of attributes, not negated
+  # Note that it doesn't allow an array of negated attributes. For info on negation stuff, see {::#not!}
+  # @param attributes [Object, Array<Object>, Negated<Object>, Negated<Array<Object>>, nil] One or more attributes to
+  #   compare to the to_check value.
+  # @param to_check [Object] What to compare the attributes to.
+  # @yield [a, e] The block will be called when a comparison happens.
+  # @yieldparam [Object] a The attribute to compare to the value to check. Will always be a single not-negated object,
+  #   all the negation and array handling is done by the method
+  # @yieldparam [Object] e The value to compare the attribute to. Will always be the value passed to the function as
+  #   to_check.
+  # @yieldreturn [true, false] Whether or not the attribute a matches the given comparison value e.
+  # @return [true, false] whether the attributes match the comparison value in at least one way.
+  def self.matches_all(attributes, to_check, &)
+    # "Zeroth" case: attributes is nil
+    return true if attributes.nil?
+
+    # First case: there's a single negated attribute
+    if attributes.is_a? Negated
+      # The contained object might also be an array, so recursively call matches_all (and negate the result)
+      return !matches_all(attributes.object, to_check, &)
+    end
+
+    # Second case: there's a single, not-negated attribute
+    return yield(attributes, to_check) unless attributes.is_a? Array
+
+    # Third case: it's an array of attributes
+    attributes.reduce(false) do |result, element|
+      result || yield(element, to_check)
+    end
+  end
+
+  # Generic event class that can be extended
+  class Event
+    # @return [Bot] the bot used to initialize this event.
+    attr_reader :bot
+
+    class << self
+      protected
+
+      # Delegates a list of methods to a particular object. This is essentially a reimplementation of ActiveSupport's
+      # `#delegate`, but without the overhead provided by the rest. Used in subclasses of `Event` to delegate properties
+      # on events to properties on data objects.
+      # @param methods [Array<Symbol>] The methods to delegate.
+      # @param hash [Hash<Symbol => Symbol>] A hash with one `:to` key and the value the method to be delegated to.
+      def delegate(*methods, hash)
+        methods.each do |e|
+          define_method(e) do
+            object = __send__(hash[:to])
+            object.__send__(e)
+          end
+        end
+      end
+    end
+  end
+
+  # Generic event handler that can be extended
+  class EventHandler
+    def initialize(attributes, block)
+      @attributes = attributes
+      @block = block
+    end
+
+    # Whether or not this event handler matches the given event with its attributes.
+    # @raise [RuntimeError] if this method is called - overwrite it in your event handler!
+    def matches?(_)
+      raise "Attempted to call matches?() from a generic EventHandler"
+    end
+
+    # Checks whether this handler matches the given event, and then calls it.
+    # @param event [Object] The event object to match and call the handler with
+    def match(event)
+      call(event) if matches? event
+    end
+
+    # Calls this handler
+    # @param event [Object] The event object to call this handler with
+    def call(event)
+      @block.call(event)
+    end
+
+    # to be overwritten by extending event handlers
+    def after_call(event)
+    end
+
+    # @see Rubycord::Events::matches_all
+    def matches_all(attributes, to_check, &)
+      Rubycord::Events.matches_all(attributes, to_check, &)
+    end
+  end
+
+  # Event handler that matches all events. Only useful for making an event that has no attributes, such as {ReadyEvent}.
+  class TrueEventHandler < EventHandler
+    # Always returns true.
+    # @return [true]
+    def matches?(_)
+      true
+    end
+  end
+end
+
+# Utility function that creates a negated object for {Rubycord::Events.matches_all}
+# @param [Object] object The object to negate
+# @see Rubycord::Events::Negated
+# @see Rubycord::Events.matches_all
+# @return [Negated<Object>] the object, negated, as an attribute to pass to matches_all
+def not!(object)
+  Rubycord::Events::Negated.new(object)
+end

data/lib/rubycord/events/guilds.rb

@@ -0,0 +1,191 @@
+require "rubycord/events/generic"
+require "rubycord/data"
+
+module Rubycord::Events
+  # Generic subclass for server events (create/update/delete)
+  class ServerEvent < Event
+    # @return [Server] the server in question.
+    attr_reader :server
+
+    def initialize(data, bot)
+      @bot = bot
+
+      init_server(data, bot)
+    end
+
+    # Initializes this event with server data. Should be overwritten in case the server doesn't exist at the time
+    # of event creation (e. g. {ServerDeleteEvent})
+    def init_server(data, bot)
+      @server = bot.server(data["id"].to_i)
+    end
+  end
+
+  # Generic event handler for member events
+  class ServerEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ServerEvent
+
+      [
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Server is created
+  # @see Rubycord::EventContainer#server_create
+  class ServerCreateEvent < ServerEvent; end
+
+  # Event handler for {ServerCreateEvent}
+  class ServerCreateEventHandler < ServerEventHandler; end
+
+  # Server is updated (e.g. name changed)
+  # @see Rubycord::EventContainer#server_update
+  class ServerUpdateEvent < ServerEvent; end
+
+  # Event handler for {ServerUpdateEvent}
+  class ServerUpdateEventHandler < ServerEventHandler; end
+
+  # Server is deleted, the server was left because the bot was kicked, or the
+  # bot made itself leave the server.
+  # @see Rubycord::EventContainer#server_delete
+  class ServerDeleteEvent < ServerEvent
+    # @return [Integer] The ID of the server that was left.
+    attr_reader :server
+
+    # Override init_server to account for the deleted server
+    def init_server(data, _bot)
+      @server = data["id"].to_i
+    end
+  end
+
+  # Event handler for {ServerDeleteEvent}
+  class ServerDeleteEventHandler < ServerEventHandler; end
+
+  # Emoji is created/deleted/updated
+  class ServerEmojiChangeEvent < ServerEvent
+    # @return [Server] the server in question.
+    attr_reader :server
+
+    # @return [Array<Emoji>] array of emojis.
+    attr_reader :emoji
+
+    def initialize(server, data, bot)
+      @bot = bot
+      @server = server
+      process_emoji(data)
+    end
+
+    # @!visibility private
+    def process_emoji(data)
+      @emoji = data["emojis"].map do |e|
+        @server.emoji[e["id"]]
+      end
+    end
+  end
+
+  # Generic event helper for when an emoji is either created or deleted
+  class ServerEmojiCDEvent < ServerEvent
+    # @return [Server] the server in question.
+    attr_reader :server
+
+    # @return [Emoji] the emoji data.
+    attr_reader :emoji
+
+    def initialize(server, emoji, bot)
+      @bot = bot
+      @emoji = emoji
+      @server = server
+    end
+  end
+
+  # Emoji is created
+  class ServerEmojiCreateEvent < ServerEmojiCDEvent; end
+
+  # Emoji is deleted
+  class ServerEmojiDeleteEvent < ServerEmojiCDEvent; end
+
+  # Emoji is updated
+  class ServerEmojiUpdateEvent < ServerEvent
+    # @return [Server] the server in question.
+    attr_reader :server
+
+    # @return [Emoji, nil] the emoji data before the event.
+    attr_reader :old_emoji
+
+    # @return [Emoji, nil] the updated emoji data.
+    attr_reader :emoji
+
+    def initialize(server, old_emoji, emoji, bot)
+      @bot = bot
+      @old_emoji = old_emoji
+      @emoji = emoji
+      @server = server
+    end
+  end
+
+  # Event handler for {ServerEmojiChangeEvent}
+  class ServerEmojiChangeEventHandler < ServerEventHandler; end
+
+  # Generic handler for emoji create and delete
+  class ServerEmojiCDEventHandler < ServerEventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ServerEmojiCDEvent
+
+      [
+        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[:id], event.emoji.id) { |a, e| a.resolve_id == e.resolve_id },
+        matches_all(@attributes[:name], event.emoji.name) { |a, e| a == e }
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Event handler for {ServerEmojiCreateEvent}
+  class ServerEmojiCreateEventHandler < ServerEmojiCDEventHandler; end
+
+  # Event handler for {ServerEmojiDeleteEvent}
+  class ServerEmojiDeleteEventHandler < ServerEmojiCDEventHandler; end
+
+  # Event handler for {ServerEmojiUpdateEvent}
+  class ServerEmojiUpdateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ServerEmojiUpdateEvent
+
+      [
+        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[:id], event.old_emoji.id) { |a, e| a.resolve_id == e.resolve_id },
+        matches_all(@attributes[:old_name], event.old_emoji.name) { |a, e| a == e },
+        matches_all(@attributes[:name], event.emoji.name) { |a, e| a == e }
+      ].reduce(true, &:&)
+    end
+  end
+end