onyxcord 1.1.0

data/lib/onyxcord/event_executor.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  # Event execution strategies used by bot dispatch.
+  module EventExecutor
+    STOP = Object.new.freeze
+
+    # Deterministic executor useful for tests, benchmarks, and tiny bots.
+    class Inline
+      def post
+        yield
+      end
+
+      def shutdown; end
+
+      def threads
+        []
+      end
+    end
+
+    # Fixed-size worker pool for event handlers.
+    class Pool
+      attr_reader :threads
+
+      def initialize(size:)
+        raise ArgumentError, 'Pool size must be greater than zero' unless size.positive?
+
+        @queue = Queue.new
+        @closed = false
+        @threads = Array.new(size) do |index|
+          Thread.new do
+            Thread.current[:onyxcord_name] = "event-worker-#{index + 1}"
+            worker_loop
+          end
+        end
+      end
+
+      def post(&block)
+        raise ArgumentError, 'EventExecutor::Pool#post requires a block' unless block
+        raise 'Event executor has been shut down' if @closed
+
+        @queue << block
+      end
+
+      def shutdown
+        return if @closed
+
+        @closed = true
+        @threads.length.times { @queue << STOP }
+        @threads.each { |thread| thread.join unless thread == Thread.current }
+      end
+
+      private
+
+      def worker_loop
+        loop do
+          job = @queue.pop
+          break if job.equal?(STOP)
+
+          job.call
+        rescue StandardError => e
+          OnyxCord::LOGGER.log_exception(e) if defined?(OnyxCord::LOGGER)
+        end
+      end
+    end
+
+    module_function
+
+    def build(type, workers:)
+      case type
+      when :inline
+        Inline.new
+      when :pool
+        Pool.new(size: workers)
+      else
+        raise ArgumentError, "Unknown event executor: #{type.inspect}"
+      end
+    end
+  end
+end

data/lib/onyxcord/events/await.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+require 'onyxcord/await'
+
+module OnyxCord::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
+
+    # @!visibility private
+    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/onyxcord/events/bans.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+
+module OnyxCord::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/onyxcord/events/channels.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+require 'onyxcord/data'
+
+module OnyxCord::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
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @channel = data.is_a?(OnyxCord::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
+
+    # @!visibility private
+    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
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+
+      @channel = bot.channel(data['channel_id'].to_i)
+      recipient = data['user']
+      recipient_user = bot.ensure_user(recipient)
+      @recipient = OnyxCord::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 message is pinned or unpinned.
+  class ChannelPinsUpdateEvent < Event
+    # @return [Time, nil] Time at which the most recent pinned message was pinned.
+    attr_reader :last_pin_timestamp
+
+    # @return [Channel] The channel this event originates from.
+    attr_reader :channel
+
+    # @return [Server, nil] The server this event originates from.
+    attr_reader :server
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+
+      @server = bot.server(data['guild_id']) if data['guild_id']
+      @channel = bot.channel(data['channel_id'])
+      @last_pin_timestamp = Time.iso8601(data['last_pin_timestamp']) if data['last_pin_timestamp']
+    end
+  end
+
+  # Event handler for ChannelPinsUpdateEvent.
+  class ChannelPinsUpdateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type.
+      return false unless event.is_a? ChannelPinsUpdateEvent
+
+      [
+        matches_all(@attributes[:server], event.server) { |a, e| a.resolve_id == e&.id },
+        matches_all(@attributes[:channel], event.channel) { |a, e| a.resolve_id == e.id }
+      ].reduce(true, &:&)
+    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/onyxcord/events/generic.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# Events used by onyxcord
+module OnyxCord::Events
+  # A negated object, used to not match something in event parameters.
+  # @see OnyxCord::Events.matches_all
+  class Negated
+    attr_reader :object
+
+    # @!visibility private
+    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, &block)
+    # "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, &block)
+    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
+    # @!visibility private
+    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 OnyxCord::Events::matches_all
+    def matches_all(attributes, to_check, &block)
+      OnyxCord::Events.matches_all(attributes, to_check, &block)
+    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 {OnyxCord::Events.matches_all}
+# @param [Object] object The object to negate
+# @see OnyxCord::Events::Negated
+# @see OnyxCord::Events.matches_all
+# @return [Negated<Object>] the object, negated, as an attribute to pass to matches_all
+def not!(object)
+  OnyxCord::Events::Negated.new(object)
+end