onyxcord 2.1.0 → 3.2.1

data/lib/onyxcord/core/bot/runtime.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  class Bot
+    module Runtime
+      # Runs the bot, which logs into Discord and connects the WebSocket. This
+      # prevents all further execution unless it is executed with
+      # `background` = `true`.
+      # @param background [true, false] If it is `true`, then the bot will run in
+      #   another thread to allow further execution. If it is `false`, this method
+      #   will block until {#stop} is called. If the bot is run with `true`, make
+      #   sure to eventually call {#join} so the script doesn't stop prematurely.
+      # @note Running the bot in the background means that you can call some
+      #   methods that require a gateway connection *before* that connection is
+      #   established. In most cases an exception will be raised if you try to do
+      #   this. If you need a way to safely run code after the bot is fully
+      #   connected, use a {#ready} event handler instead.
+      def run(background = false)
+        if background
+          @run_task = Internal::AsyncRuntime.async { run_forever }
+          return @run_task
+        end
+
+        Internal::AsyncRuntime.run { run_forever }
+      end
+
+      def run_forever
+        @gateway.run
+      end
+
+      def join
+        @run_task&.wait
+      end
+      alias_method :sync, :join
+
+      def stop(_no_sync = nil)
+        @gateway.stop
+        @event_executor.shutdown
+        @run_task&.stop if @run_task.respond_to?(:stop)
+        nil
+      end
+
+      # @return [true, false] whether or not the bot is currently connected to Discord.
+      def connected?
+        @gateway.open?
+      end
+
+      # Sets debug mode. If debug mode is on, many things will be outputted to STDOUT.
+      def debug=(new_debug)
+        LOGGER.debug = new_debug
+      end
+
+      # Sets the logging mode
+      # @see Logger#mode=
+      def mode=(new_mode)
+        LOGGER.mode = new_mode
+      end
+
+      def runtime_stats
+        {
+          mode: @mode,
+          cache: cache_stats,
+          event_executor: @event_executor.class.name,
+          event_threads: @event_threads&.count(&:alive?) || 0,
+          event_queue_size: @event_executor.respond_to?(:queue_size) ? @event_executor.queue_size : 0
+        }
+      end
+
+      # Prevents the READY packet from being printed regardless of debug mode.
+      def suppress_ready_debug
+        @prevent_ready = true
+      end
+
+      private
+
+      # Throws a useful exception if there's currently no gateway connection.
+      def gateway_check
+        raise "A gateway connection is necessary to call this method! You'll have to do it inside any event (e.g. `ready`) or after `bot.run :async`." unless connected?
+      end
+
+      # Logs a warning if there are servers which are still unavailable.
+      # e.g. due to a Discord outage or because the servers are large and taking a while to load.
+      def unavailable_servers_check
+        # Return unless there are servers that are unavailable.
+        return unless @unavailable_servers&.positive?
+
+        LOGGER.warn("#{@unavailable_servers} servers haven't been cached yet.")
+        LOGGER.warn('Servers may be unavailable due to an outage, or your bot is on very large servers that are taking a while to load.')
+      end
+
+      def process_token(type, token)
+        # Remove the "Bot " prefix if it exists
+        token = token[4..] if token.start_with? 'Bot '
+
+        token = "Bot #{token}" unless type == :user
+        token
+      end
+
+      # Notifies everything there is to be notified that the connection is now ready
+      def notify_ready
+        if @mode == :raw
+          notify_raw_ready
+          return
+        end
+
+        # Make sure to raise the event
+        raise_event(OnyxCord::Events::ReadyEvent.new(self))
+        LOGGER.good 'Ready'
+
+        @gateway.notify_ready
+      end
+
+      def raise_event(event)
+        debug("Raised a #{event.class}")
+        handle_awaits(event)
+
+        @event_handlers ||= {}
+        handlers = @event_handlers[event.class]
+        return unless handlers
+
+        handlers.dup.each do |handler|
+          call_event(handler, event) if handler.matches?(event)
+        end
+      end
+
+      def call_event(handler, event)
+        @event_executor.post do
+          Thread.current[:onyxcord_name] = next_event_thread_name('et')
+          begin
+            handler.call(event)
+            handler.after_call(event)
+          rescue StandardError => e
+            log_exception(e)
+          end
+        end
+      end
+
+      def handle_awaits(event)
+        @awaits ||= {}
+        @awaits.each_value do |await|
+          key, should_delete = await.match(event)
+          next unless key
+
+          debug("should_delete: #{should_delete}")
+          @awaits.delete(await.key) if should_delete
+
+          await_event = OnyxCord::Events::AwaitEvent.new(await, event, self)
+          raise_event(await_event)
+        end
+      end
+
+      def calculate_intents(intents)
+        intents = [intents] unless intents.is_a? Array
+
+        intents.reduce(0) do |sum, intent|
+          case intent
+          when Symbol
+            intent = INTENT_ALIASES[intent] || intent
+
+            if INTENTS[intent]
+              sum | INTENTS[intent]
+            else
+              LOGGER.warn("Unknown intent: #{intent}")
+              sum
+            end
+          when Integer
+            sum | intent
+          else
+            LOGGER.warn("Invalid intent: #{intent}")
+            sum
+          end
+        end
+      end
+
+      def next_event_thread_name(prefix)
+        @current_thread_mutex.synchronize do
+          @current_thread += 1
+          "#{prefix}-#{@current_thread}"
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/core/bot/voice.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  class Bot
+    module VoiceControl
+      # @return [Hash<Integer => Client>] the voice connections this bot currently has, by the server ID to which they are connected.
+      attr_reader :voices
+
+      # Gets the voice bot for a particular server or channel. You can connect to a new channel using the {#voice_connect}
+      # method.
+      # @param thing [Channel, Server, Integer] the server or channel you want to get the voice bot for, or its ID.
+      # @return [Voice::Client, nil] the Client for the thing you specified, or nil if there is no connection yet
+      def voice(thing)
+        id = thing.resolve_id
+        return @voices[id] if @voices[id]
+
+        channel = channel(id)
+        return nil unless channel
+
+        server_id = channel.server.id
+        return @voices[server_id] if @voices[server_id]
+      end
+
+      # Connects to a voice channel, initializes network connections and returns the {Voice::Client} over which audio
+      # data can then be sent. After connecting, the bot can also be accessed using {#voice}. If the bot is already
+      # connected to voice, the existing connection will be terminated - you don't have to call
+      # {OnyxCord::Voice::Client#destroy} before calling this method.
+      # @param chan [Channel, String, Integer] The voice channel, or its ID, to connect to.
+      # @param encrypted [true, false] Whether voice communication should be encrypted using
+      #   (uses an XSalsa20 stream cipher for encryption and Poly1305 for authentication)
+      # @return [Voice::Client] the initialized bot over which audio data can then be sent.
+      def voice_connect(chan, encrypted = true)
+        raise ArgumentError, 'Unencrypted voice connections are no longer supported.' unless encrypted
+
+        chan = channel(chan.resolve_id)
+        server_id = chan.server.id
+
+        if @voices[chan.id]
+          debug('Voice bot exists already! Destroying it')
+          @voices[chan.id].destroy
+          @voices.delete(chan.id)
+        end
+
+        debug("Got voice channel: #{chan}")
+
+        @should_connect_to_voice[server_id] = chan
+        @gateway.send_voice_state_update(server_id.to_s, chan.id.to_s, false, false)
+
+        debug('Voice channel init packet sent! Now waiting.')
+
+        Internal::AsyncRuntime.sleep(0.05) until @voices[server_id]
+        debug('Voice connect succeeded!')
+        @voices[server_id]
+      end
+
+      # Disconnects the client from a specific voice connection given the server ID. Usually it's more convenient to use
+      # {OnyxCord::Voice::Client#destroy} rather than this.
+      # @param server [Server, String, Integer] The server, or server ID, the voice connection is on.
+      # @param destroy_vws [true, false] Whether or not the VWS should also be destroyed. If you're calling this method
+      #   directly, you should leave it as true.
+      def voice_destroy(server, destroy_vws = true)
+        server = server.resolve_id
+        @gateway.send_voice_state_update(server.to_s, nil, false, false)
+        @voices[server].destroy if @voices[server] && destroy_vws
+        @voices.delete(server)
+      end
+    end
+  end
+end

data/lib/onyxcord/{logger.rb → core/logger.rb}

@@ -81,6 +81,11 @@ module OnyxCord
     # Logs an exception to the console.
     # @param e [Exception] The exception to log.
     def log_exception(e)
+      if defined?(OnyxCord::Errors::UnknownMessage) && e.is_a?(OnyxCord::Errors::UnknownMessage)
+        warn('Ignoring stale Discord message reference.')
+        return
+      end
+
       error("Exception: #{e.inspect}")
       e.backtrace.each { |line| error(line) }
     end

data/lib/onyxcord/core/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  VERSION = '3.2.1'
+end

data/lib/onyxcord/events/await/base.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/await.rb

@@ -1,48 +1,3 @@
 # 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
+require 'onyxcord/events/await/base'

data/lib/onyxcord/events/ban/base.rb

@@ -0,0 +1,54 @@
+# 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
+end

data/lib/onyxcord/events/ban/remove.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/ban/base'
+
+module OnyxCord::Events
+  # 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/bans.rb

@@ -1,60 +1,4 @@
 # 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
+require 'onyxcord/events/ban/base'
+require 'onyxcord/events/ban/remove'

data/lib/onyxcord/events/channels/base.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+require 'onyxcord/models'
+
+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 = if data.is_a?(OnyxCord::Channel)
+                   data
+                 else
+                   cached_channel(bot, data['id']) || OnyxCord::Channel.new(data, bot, cached_server(bot, data['guild_id']))
+                 end
+    end
+
+    def cached_channel(bot, channel_id)
+      channels = bot.instance_variable_get(:@channels)
+      channels&.[](channel_id.to_i)
+    end
+
+    def cached_server(bot, server_id)
+      return nil unless server_id
+
+      servers = bot.instance_variable_get(:@servers)
+      servers&.[](server_id.to_i)
+    end
+  end
+
+  # Event handler for ChannelCreateEvent
+
+  # 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
+
+  # Raised when a channel is updated (e.g. topic changes)
+  class ChannelUpdateEvent < ChannelCreateEvent; end
+
+  # Event handler for ChannelUpdateEvent
+
+  # Event handler for ChannelUpdateEvent
+  class ChannelUpdateEventHandler < ChannelCreateEventHandler; end
+end

data/lib/onyxcord/events/channels/delete.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'onyxcord/events/generic'
+require 'onyxcord/models'
+
+module OnyxCord::Events
+  # 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
+
+  # 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)
+end