onyxcord 2.0.0 → 2.0.6

data/lib/onyxcord/application_commands/registry.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module ApplicationCommands
+    class Registry
+      attr_reader :bot, :commands
+
+      def initialize(bot)
+        @bot = bot
+        @commands = {}
+      end
+
+      def slash(name, description:, **attributes, &block)
+        register(Command.chat_input(name, description: description, **attributes, &block))
+      end
+
+      def user(name, **attributes, &block)
+        register(Command.user(name, **attributes, &block))
+      end
+
+      def message(name, **attributes, &block)
+        register(Command.message(name, **attributes, &block))
+      end
+
+      def register(command)
+        @commands[command.name] = command
+        wire_handler(command)
+        command
+      end
+
+      def sync!(server_id: nil, delete_unknown: false)
+        payload = @commands.values.map(&:to_h)
+
+        if server_id
+          @bot.bulk_overwrite_guild_application_commands(server_id, payload)
+        else
+          @bot.bulk_overwrite_global_application_commands(payload)
+        end
+      end
+
+      private
+
+      def wire_handler(command)
+        @bot.application_command(command.name) do |event|
+          command.call(Context.new(event, command))
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/application_commands.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'onyxcord/application_commands/option'
+require 'onyxcord/application_commands/command'
+require 'onyxcord/application_commands/context'
+require 'onyxcord/application_commands/registry'
+
+module OnyxCord
+  module ApplicationCommands
+  end
+end

data/lib/onyxcord/async/runtime.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'async'
+
+module OnyxCord
+  module AsyncRuntime
+    module_function
+
+    def run(&block)
+      current = Async::Task.current?
+      return yield current if current
+
+      Async(&block).wait
+    end
+
+    def async(&block)
+      current = Async::Task.current?
+      return current.async(&block) if current
+
+      Async(&block)
+    end
+
+    def sleep(duration)
+      task = Async::Task.current?
+      return task.sleep(duration) if task.respond_to?(:sleep)
+
+      Kernel.sleep(duration)
+    end
+  end
+end

data/lib/onyxcord/bot.rb

@@ -33,6 +33,7 @@ require 'onyxcord/api/invite'
 require 'onyxcord/api/interaction'
 require 'onyxcord/api/application'
 
+require 'onyxcord/async/runtime'
 require 'onyxcord/errors'
 require 'onyxcord/message_components'
 require 'onyxcord/data'
@@ -42,6 +43,7 @@ require 'onyxcord/websocket'
 require 'onyxcord/cache'
 require 'onyxcord/gateway'
 
+require 'onyxcord/application_commands'
 require 'onyxcord/voice/voice_bot'
 
 module OnyxCord
@@ -309,28 +311,27 @@ module OnyxCord
     #   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)
-      @gateway.run_async
-      return if background
+      if background
+        @run_task = OnyxCord::AsyncRuntime.async { run_forever }
+        return @run_task
+      end
+
+      OnyxCord::AsyncRuntime.run { run_forever }
+    end
 
-      debug('Oh wait! Not exiting yet as run was run synchronously.')
-      @gateway.sync
+    def run_forever
+      @gateway.run
     end
 
-    # Joins the bot's connection thread with the current thread.
-    # This blocks execution until the websocket stops, which should only happen
-    # manually triggered. or due to an error. This is necessary to have a
-    # continuously running bot.
     def join
-      @gateway.sync
+      @run_task&.wait
     end
     alias_method :sync, :join
 
-    # Stops the bot gracefully, disconnecting the websocket without immediately killing the thread. This means that
-    # Discord is immediately aware of the closed connection and makes the bot appear offline instantly.
-    # @note This method no longer takes an argument as of 3.4.0
     def stop(_no_sync = nil)
       @gateway.stop
       @event_executor.shutdown
+      @run_task&.stop if @run_task.respond_to?(:stop)
       nil
     end
 
@@ -411,7 +412,7 @@ module OnyxCord
 
       debug('Voice channel init packet sent! Now waiting.')
 
-      sleep(0.05) until @voices[server_id]
+      OnyxCord::AsyncRuntime.sleep(0.05) until @voices[server_id]
       debug('Voice connect succeeded!')
       @voices[server_id]
     end
@@ -477,9 +478,9 @@ module OnyxCord
     # @param enforce_nonce [true, false] Whether the nonce should be enforced and used for message de-duplication.
     # @param poll [Hash, Poll::Builder, Poll, nil] The poll that should be attached to this message.
     def send_temporary_message(channel, content, timeout, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, nonce = nil, enforce_nonce = false, poll = nil)
-      Async do
+      OnyxCord::AsyncRuntime.async do
         message = send_message(channel, content, tts, embeds, attachments, allowed_mentions, message_reference, components, flags, nonce, enforce_nonce, poll)
-        sleep(timeout)
+        OnyxCord::AsyncRuntime.sleep(timeout)
         message.delete
       end
 
@@ -864,6 +865,37 @@ module OnyxCord
       ApplicationCommand.new(JSON.parse(resp), self, server_id)
     end
 
+    # @return [OnyxCord::ApplicationCommands::Registry]
+    def commands
+      @modern_command_registry ||= OnyxCord::ApplicationCommands::Registry.new(self)
+    end
+
+    def slash(name, description: nil, **attributes, &block)
+      commands.slash(name, description: description, **attributes, &block)
+    end
+
+    def user_command(name, **attributes, &block)
+      commands.user(name, **attributes, &block)
+    end
+
+    def message_command(name, **attributes, &block)
+      commands.message(name, **attributes, &block)
+    end
+
+    def sync_application_commands!(server_id: nil, delete_unknown: false)
+      commands.sync!(server_id: server_id, delete_unknown: delete_unknown)
+    end
+
+    def bulk_overwrite_global_application_commands(commands)
+      response = API::Application.bulk_overwrite_global_commands(@token, profile.id, commands)
+      JSON.parse(response).map { |data| ApplicationCommand.new(data, self) }
+    end
+
+    def bulk_overwrite_guild_application_commands(server_id, commands)
+      response = API::Application.bulk_overwrite_guild_commands(@token, profile.id, server_id.resolve_id, commands)
+      JSON.parse(response).map { |data| ApplicationCommand.new(data, self, server_id) }
+    end
+
     # @yieldparam [OptionBuilder]
     # @yieldparam [PermissionBuilder]
     # @example

data/lib/onyxcord/data/interaction.rb

@@ -299,6 +299,10 @@ module OnyxCord
       Interactions::Message.new(JSON.parse(resp), @bot, self)
     end
 
+    alias edit_original edit_response
+    alias delete_original delete_response
+    alias followup send_message
+
     # @param message [String, Integer, InteractionMessage, Message] The message created by this interaction to be edited.
     # @param content [String] The message content.
     # @param embeds [Array<Hash, Webhooks::Embed>] The embeds for the message.

data/lib/onyxcord/event_executor.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require 'async'
+require 'onyxcord/async/runtime'
 
 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
@@ -20,8 +18,6 @@ module OnyxCord
       end
     end
 
-    # Async-based worker pool for event handlers.
-    # Uses Async tasks (fibers) instead of threads for lightweight concurrency.
     class Pool
       attr_reader :queue
 
@@ -47,7 +43,6 @@ module OnyxCord
         @queue.size
       end
 
-      # Compatibility with code that checks worker threads.
       def threads
         @workers
       end
@@ -87,6 +82,59 @@ module OnyxCord
       end
     end
 
+    class AsyncPool
+      attr_reader :queue
+
+      def initialize(size:, queue_size: nil)
+        raise ArgumentError, 'Pool size must be greater than zero' unless size.positive?
+
+        @size = size
+        @queue = ::Async::Queue.new
+        @closed = false
+        @workers = []
+        start_workers
+      end
+
+      def post(&block)
+        raise ArgumentError, 'EventExecutor::AsyncPool#post requires a block' unless block
+        raise 'Event executor has been shut down' if @closed
+
+        @queue.enqueue(block)
+      end
+
+      def queue_size
+        @queue.size
+      end
+
+      def shutdown
+        return if @closed
+
+        @closed = true
+        @size.times { @queue.enqueue(STOP) }
+      end
+
+      def threads
+        []
+      end
+
+      private
+
+      def start_workers
+        @workers = Array.new(@size) do
+          OnyxCord::AsyncRuntime.async do
+            loop do
+              job = @queue.dequeue
+              break if job.equal?(STOP)
+
+              job.call
+            rescue StandardError => e
+              OnyxCord::LOGGER.log_exception(e) if defined?(OnyxCord::LOGGER)
+            end
+          end
+        end
+      end
+    end
+
     module_function
 
     def build(type, workers:, queue_size: nil)
@@ -95,6 +143,8 @@ module OnyxCord
         Inline.new
       when :pool
         Pool.new(size: workers, queue_size: queue_size)
+      when :async_pool
+        AsyncPool.new(size: workers, queue_size: queue_size)
       else
         raise ArgumentError, "Unknown event executor: #{type.inspect}"
       end

data/lib/onyxcord/gateway.rb

@@ -3,6 +3,7 @@
 require 'async'
 require 'async/http/endpoint'
 require 'async/websocket/client'
+require 'onyxcord/async/runtime'
 require 'onyxcord/rate_limiter/gateway'
 
 module OnyxCord
@@ -86,25 +87,24 @@ module OnyxCord
 
     # Connect to the gateway server inside an Async reactor.
     def run_async
-      @ws_thread = Thread.new do
-        Thread.current[:onyxcord_name] = 'gateway'
-        Async do |task|
-          @reactor_task = task
-          connect_loop
-          LOGGER.warn('The gateway loop exited!')
-        end
-      end
+      @task = OnyxCord::AsyncRuntime.async { run }
 
-      LOGGER.debug('Gateway thread created! Waiting for confirmation...')
+      LOGGER.debug('Gateway task created! Waiting for confirmation...')
       loop do
-        sleep(0.5)
+        OnyxCord::AsyncRuntime.sleep(0.5)
         break if @ws_success
         break if @should_reconnect == false
       end
     end
 
+    def run
+      @reactor_task = Async::Task.current
+      connect_loop
+      LOGGER.warn('The gateway loop exited!')
+    end
+
     def sync
-      @ws_thread&.join
+      @task&.wait
     end
 
     def open?
@@ -118,7 +118,7 @@ module OnyxCord
     end
 
     def kill
-      @ws_thread&.kill
+      @task&.stop
     end
 
     def notify_ready
@@ -224,7 +224,7 @@ module OnyxCord
       @heartbeat_task = @reactor_task&.async do
         loop do
           if (@session && !@session.suspended?) || !@session
-            sleep @heartbeat_interval
+            OnyxCord::AsyncRuntime.sleep(@heartbeat_interval)
             if !@closed && @connection
               @bot.raise_heartbeat_event
               heartbeat
@@ -232,7 +232,7 @@ module OnyxCord
               LOGGER.debug('Tried to heartbeat without connection — skipping.')
             end
           else
-            sleep 1
+            OnyxCord::AsyncRuntime.sleep(1)
           end
         rescue StandardError => e
           LOGGER.error('Error while heartbeating!')
@@ -260,7 +260,7 @@ module OnyxCord
 
     def wait_for_reconnect
       LOGGER.debug("Reconnecting in #{@falloff} seconds.")
-      sleep @falloff
+      OnyxCord::AsyncRuntime.sleep(@falloff)
       @falloff *= 1.5
       @falloff = 115 + (rand * 10) if @falloff > 120
     end

data/lib/onyxcord/http.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'httpx'
+require 'onyxcord/json'
+
+module OnyxCord
+  # Modern HTTP adapter wrapping HTTPX with persistent connections, automatic
+  # retries on 502, and a response interface compatible with the rest of OnyxCord.
+  module HTTP
+    # Lightweight response wrapper so call-sites that relied on RestClient's
+    # `.body`, `.headers`, `.code` interface keep working unchanged.
+    class Response
+      # @return [String] the response body
+      attr_reader :body
+
+      # @return [Integer] the HTTP status code
+      attr_reader :code
+
+      # @return [Hash] the response headers (symbol keys, underscored)
+      attr_reader :headers
+
+      def initialize(httpx_response)
+        @raw = httpx_response
+        @body = httpx_response.body.to_s
+        @code = httpx_response.status
+        @headers = normalize_headers(httpx_response.headers)
+      end
+
+      def to_s
+        @body
+      end
+
+      # RestClient compatibility — some code calls `response` directly as a
+      # string (implicit to_s).
+      alias_method :to_str, :to_s
+
+      private
+
+      def normalize_headers(headers)
+        headers.to_h.transform_keys do |key|
+          key.to_s.tr('-', '_').downcase.to_sym
+        end
+      end
+    end
+
+    module_function
+
+    # The shared HTTPX session with persistent connections.
+    def session
+      @session ||= HTTPX.plugin(:persistent)
+                        .plugin(:follow_redirects)
+    end
+
+    # Reset the HTTP session (useful for tests).
+    def reset!
+      @session = nil
+    end
+
+    # Perform a raw HTTP request and return a {Response}.
+    # @param type [Symbol] HTTP method (:get, :post, :put, :patch, :delete)
+    # @param url [String] The full URL.
+    # @param body [String, Hash, nil] The request body.
+    # @param headers [Hash] Request headers.
+    # @return [Response]
+    def request(type, url, body = nil, **headers)
+      http = session.with(headers: headers)
+
+      raw = case type
+            when :get
+              http.get(url)
+            when :post
+              if body.is_a?(Hash) && body.any? { |_, v| v.respond_to?(:read) || v.respond_to?(:path) }
+                # Multipart upload
+                http.plugin(:multipart).post(url, form: body)
+              else
+                http.post(url, body: body)
+              end
+            when :put
+              http.put(url, body: body)
+            when :patch
+              http.patch(url, body: body)
+            when :delete
+              http.delete(url)
+            else
+              raise ArgumentError, "Unknown HTTP method: #{type}"
+            end
+
+      # HTTPX returns an error response object on network failures
+      raise raw.error if raw.is_a?(HTTPX::ErrorResponse)
+
+      Response.new(raw)
+    end
+
+    # Convenience wrappers
+    def get(url, **headers)
+      request(:get, url, nil, **headers)
+    end
+
+    def post(url, body = nil, **headers)
+      request(:post, url, body, **headers)
+    end
+
+    def put(url, body = nil, **headers)
+      request(:put, url, body, **headers)
+    end
+
+    def patch(url, body = nil, **headers)
+      request(:patch, url, body, **headers)
+    end
+
+    def delete(url, **headers)
+      request(:delete, url, nil, **headers)
+    end
+  end
+end

data/lib/onyxcord/json.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+# Configure Oj in compat mode so that all stdlib JSON.parse / .to_json calls
+# are transparently accelerated. This is loaded early by the main onyxcord.rb
+# entry point so every module benefits automatically.
+module OnyxCord
+  # Fast Oj-backed JSON wrapper providing compatibility with stdlib JSON methods.
+  module JSON
+    Oj.default_options = { mode: :compat, symbol_keys: false }
+
+    module_function
+
+    # Fast JSON decode using Oj via stdlib JSON compatibility.
+    # @param data [String] The JSON string to decode.
+    # @return [Hash, Array, String, Numeric, nil]
+    def decode(data, *args)
+      ::JSON.parse(data, *args)
+    end
+
+    # Fast JSON encode using Oj via stdlib JSON compatibility.
+    # @param data [Object] The object to encode as JSON.
+    # @return [String]
+    def encode(data, *args)
+      ::JSON.generate(data, *args)
+    end
+
+    # Alias parse to decode for standard library compatibility
+    def parse(data, *args)
+      ::JSON.parse(data, *args)
+    end
+
+    # Alias generate to encode for standard library compatibility
+    def generate(data, *args)
+      ::JSON.generate(data, *args)
+    end
+
+    # Alias load to decode for Oj/JSON compatibility
+    def load(data, *args)
+      ::JSON.parse(data, *args)
+    end
+
+    # Alias dump to encode for Oj/JSON compatibility
+    def dump(data, *args)
+      ::JSON.generate(data, *args)
+    end
+  end
+end