onyxcord 2.0.0 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '00639da6b7f1bb86015ad2789db3c8a31a8a2865d26d594bb0bdf15914dbb534'
-  data.tar.gz: 0ac2f4e68b91633c3d1006faf2def1d6df6a99a9898fc2c38de819d5048f41f4
+  metadata.gz: c794e2e7f5ad51dea52e27c049fb7d08fb7b54c84b452243fe549cd54f46dd5d
+  data.tar.gz: 2f7e1a9df9cf56085e31dd7bc13e843f8c5bee2e9083817305e6936117c92dd4
 SHA512:
-  metadata.gz: ae1eab8467d518c3bd98148274b3bc152e1c9d8b72696c27fe621e069a7d2ff75ff33dddfda22b00702f25a85b38702a31accaf1d00d0366d831cc96b38cea3b
-  data.tar.gz: dc2bb8086656c80b8d97c7992f99a75aed3efd7481a9de4c52713edbbc02536ab6074d27931b88430b92a72a3b5412e58fdff8ee5ccb4e936edd19f08c7edbc0
+  metadata.gz: dce8555d60a8bf6662bfc357c64918e75ff803ab30c43c93dab390756ee52e0057f20914367ec4cce89e5a6906c0745f99b89f42953bb9b91648caa3fe296378
+  data.tar.gz: 7b25cd2d344182abbdce7fb5f74f8cffb7dea3ad478d6a03e9018ea138635fac13e9203184f656f677c39b85b26f1a8287f24ac6a855b5b9ae64ec12165e8c72

data/.gitignore

@@ -9,6 +9,7 @@
 /profiles/
 /tmp/
 /.idea/
+/obsidian/
 .DS_Store
 *.gem
 **.sw*

data/CHANGELOG.md

@@ -1,5 +1,60 @@
 # Changelog
 
+## 2.0.6 - 2026-06-28
+
+### Correcoes de empacotamento
+
+- Incluidos na gem os arquivos da infraestrutura async que ficaram fora do pacote `2.0.5`: `onyxcord/async/runtime` e `onyxcord/rate_limiter/async_rest`.
+- Incluidos na gem os arquivos da DSL moderna de application commands: `onyxcord/application_commands` e seus componentes internos.
+- Corrige `LoadError: cannot load such file -- onyxcord/async/runtime` ao usar a gem publicada.
+
+## 2.0.5 - 2026-06-28
+
+### Async Runtime (Infraestrutura nao-bloqueante)
+
+- **`OnyxCord::AsyncRuntime`**: modulo central que gerencia o reactor `async` com `run`, `async` e `sleep`, reaproveitando reactor existente quando disponivel.
+- **`EventExecutor::AsyncPool`**: novo pool de workers baseado em `Async::Queue` e fibers, sem threads.
+- **Gateway**: `run_async` nao cria mais `Thread.new` — usa `@task = AsyncRuntime.async { run }`. Todos os `sleep` trocados por `AsyncRuntime.sleep`.
+- **WebSocket**: usa `AsyncRuntime.async` em vez de `Async do` solto na classe.
+- **API REST**: `request` agora delega para `request_async` automaticamente quando dentro de um reactor. `request_async` usa rate limiter async, `AsyncRuntime.sleep`, e retry com limite em 502.
+- **Rate Limiter Async**: novo `OnyxCord::RateLimiter::AsyncRest` que evita `mutex.synchronize { sleep }` bloqueante.
+- **Bot**: `run`/`stop`/`join` refatorados para o runtime async. `send_temporary_message` e `voice_connect` usam sleeps async.
+- Compatibilidade sync mantida: a API publica continua funcionando de forma sincrona quando chamada fora de um reactor.
+
+### Modern Application Commands DSL
+
+- **`bot.slash`, `bot.user_command`, `bot.message_command`**: nova DSL para comandos modernos com definicao e handler unificados.
+- **`bot.sync_application_commands!`**: sincroniza todos os commands registrados com a API do Discord de uma vez.
+- **`bot.bulk_overwrite_global_application_commands`** e **`bot.bulk_overwrite_guild_application_commands`**: wrappers para bulk overwrite.
+- **`ApplicationCommands::Context`**: wrapper com `respond`, `defer`, `edit_original`, `delete_original`, `followup` e acesso a `options`, `guild`, `channel`, `user`.
+- **`Interaction#edit_original`**, **`Interaction#delete_original`**, **`Interaction#followup`**: novos aliases dos metodos originais.
+- API legacy (`register_application_command` + `application_command`) mantida com compatibilidade total.
+
+### Exemplo da nova DSL
+
+```ruby
+bot.slash :ban, description: "Bane um membro", default_member_permissions: [:ban_members] do
+  user :member, "Membro que sera banido", required: true
+  string :reason, "Motivo do banimento", max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || "Sem motivo informado"
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: "Membro banido com sucesso.")
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
+### Validacao
+
+- `bundle exec rspec`: 460 exemplos, 0 falhas, 3 pendentes.
+- `ruby -c lib/onyxcord/**/*.rb`: todos os arquivos com sintaxe OK.
+- `gem build onyxcord.gemspec`: sucesso.
+
 ## 2.0.0 - 2026-06-28
 
 ### Arquitetura & Performance (Major Refactoring)

data/README.md

@@ -22,6 +22,8 @@ Simple to start, deep enough to control.
 - Friendly Ruby API for Discord bots.
 - Traditional object events for productivity.
 - Raw gateway events for performance and lower allocation.
+- **Modern async runtime** built on `async` gem with non-blocking gateway, REST and event dispatch.
+- **New modern slash command DSL** with `bot.slash`, `execute`, and `bot.sync_application_commands!`.
 - Components V2 support with `Text Display`, `Container`, `Section`, `Media Gallery`, `File`, `Separator`, and `Thumbnail`.
 - Modern modal components, including `Label`, `Text Display`, modal selects, file upload, radio group, checkbox group, and checkbox.
 - Webhooks with embeds, files, and components.
@@ -112,6 +114,25 @@ bot.application_command(:feedback) do |event|
 end
 ```
 
+### Modern Command DSL
+
+```ruby
+bot.slash :ban, description: 'Ban a member', default_member_permissions: [:ban_members] do
+  user :member, 'Member to ban', required: true
+  string :reason, 'Ban reason', max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || 'No reason provided'
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: 'Member banned.')
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
 ### Community
 
 Join the Discord server for support, updates, examples, and feedback: https://discord.gg/Jy2tpCUtzM
@@ -131,6 +152,8 @@ Simples para comecar, profundo para controlar.
 - API Ruby amigavel para bots do Discord.
 - Eventos tradicionais com objetos para quem quer produtividade.
 - Eventos raw para quem quer performance e menos alocacao.
+- **Runtime async moderno** baseado na gem `async`: gateway, REST e dispatch de eventos nao-bloqueantes.
+- **Nova DSL moderna de slash commands** com `bot.slash`, `execute` e `bot.sync_application_commands!`.
 - Components V2 com `Text Display`, `Container`, `Section`, `Media Gallery`, `File`, `Separator` e `Thumbnail`.
 - Novos componentes de modal, incluindo `Label`, `Text Display`, selects em modal, upload, radio group, checkbox group e checkbox.
 - Webhooks com embeds, arquivos e componentes.
@@ -221,6 +244,25 @@ bot.application_command(:feedback) do |event|
 end
 ```
 
+### DSL Moderna de Comandos
+
+```ruby
+bot.slash :ban, description: 'Bane um membro', default_member_permissions: [:ban_members] do
+  user :member, 'Membro que sera banido', required: true
+  string :reason, 'Motivo do banimento', max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || 'Sem motivo informado'
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: 'Membro banido com sucesso.')
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
 ### Comunidade
 
 Entre no servidor do Discord para suporte, atualizacoes, exemplos e feedback: https://discord.gg/Jy2tpCUtzM
@@ -237,9 +279,11 @@ Simple para empezar, profundo para controlar.
 
 ### Caracteristicas
 
-- API Ruby amigable para bots de Discord.
+- API Ruby amigavel para bots de Discord.
 - Eventos tradicionales con objetos para productividad.
 - Eventos raw para rendimiento y menos asignaciones.
+- **Runtime async moderno** basado en la gem `async`: gateway, REST y dispatch de eventos no bloqueantes.
+- **Nueva DSL moderna de slash commands** con `bot.slash`, `execute` y `bot.sync_application_commands!`.
 - Components V2 con `Text Display`, `Container`, `Section`, `Media Gallery`, `File`, `Separator` y `Thumbnail`.
 - Componentes modernos de modal, incluyendo `Label`, `Text Display`, selects en modal, subida de archivos, radio group, checkbox group y checkbox.
 - Webhooks con embeds, archivos y componentes.
@@ -330,6 +374,25 @@ bot.application_command(:feedback) do |event|
 end
 ```
 
+### DSL Moderna de Comandos
+
+```ruby
+bot.slash :ban, description: 'Banear a un miembro', default_member_permissions: [:ban_members] do
+  user :member, 'Miembro a banear', required: true
+  string :reason, 'Motivo del baneo', max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || 'Sin motivo'
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: 'Miembro baneado.')
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
 ### Comunidad
 
 Unete al servidor de Discord para soporte, actualizaciones, ejemplos y feedback: https://discord.gg/Jy2tpCUtzM

data/lib/onyxcord/api.rb

@@ -2,10 +2,12 @@
 
 require 'onyxcord/http'
 require 'onyxcord/json'
+require 'onyxcord/async/runtime'
 require 'time'
 
 require 'onyxcord/errors'
 require 'onyxcord/rate_limiter/rest'
+require 'onyxcord/rate_limiter/async_rest'
 
 # List of methods representing endpoints in Discord's API
 module OnyxCord::API
@@ -61,16 +63,25 @@ module OnyxCord::API
   # Resets all rate limit mutexes
   def reset_mutexes
     @rate_limiter = OnyxCord::RateLimiter::Rest.new
+    @async_rate_limiter = OnyxCord::RateLimiter::AsyncRest.new
   end
 
   def rate_limiter
     @rate_limiter ||= OnyxCord::RateLimiter::Rest.new
   end
 
+  def async_rate_limiter
+    @async_rate_limiter ||= OnyxCord::RateLimiter::AsyncRest.new
+  end
+
   def rate_limiter_stats
     rate_limiter.stats
   end
 
+  def async_rate_limiter_stats
+    async_rate_limiter.stats
+  end
+
   # Wait a specified amount of time synchronised with the specified mutex.
   def sync_wait(time, mutex)
     mutex.synchronize { sleep time }
@@ -110,11 +121,18 @@ module OnyxCord::API
 
   # Make an API request, including rate limit handling.
   def request(key, major_parameter, type, *attributes)
-    # Parse attributes: URL is first, body is second (if present), rest is headers hash
+    if Async::Task.current?
+      request_async(key, major_parameter, type, *attributes)
+    else
+      OnyxCord::AsyncRuntime.run { request_async(key, major_parameter, type, *attributes) }
+    end
+  end
+
+  # Async version of request.
+  def request_async(key, major_parameter, type, *attributes)
     url = attributes.shift
     headers_or_body = attributes
 
-    # Separate body and headers from the positional args
     body = nil
     headers = {}
 
@@ -126,89 +144,74 @@ module OnyxCord::API
       end
     end
 
-    # Extract content_type from headers for HTTPX
     content_type = headers.delete(:content_type)
     headers['content-type'] = 'application/json' if content_type == :json
 
-    # Add user agent
     headers['user-agent'] = user_agent
 
+    retries = 0
+    max_retries = key == :gateway ? 0 : 3
+
     begin
-      rate_limiter.before_request(key, major_parameter)
+      async_rate_limiter.before_request(key, major_parameter)
 
       response = nil
-      begin
+      loop do
         response = OnyxCord::HTTP.request(type, url, body, **headers)
+        break unless response.code == 502
 
-        if response.code == 403
-          noprm = OnyxCord::Errors::NoPermission.new
-          noprm.define_singleton_method(:_response) { response }
-          raise noprm, "The bot doesn't have the required permission to do this!"
-        end
+        retries += 1
+        break unless retries < max_retries
 
-        # Retry on 502
-        if response.code == 502
-          OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
-          return request(key, major_parameter, type, url, body, headers)
-        end
-
-        # Handle error status codes
-        if response.code >= 400 && response.code != 429
-          data = begin
-            JSON.parse(response.body)
-          rescue StandardError
-            nil
-          end
+        OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
+        OnyxCord::AsyncRuntime.sleep(retries * 0.5)
+      end
 
-          raise "HTTP #{response.code}: #{response.body}" unless data
+      if response.code == 403
+        noprm = OnyxCord::Errors::NoPermission.new
+        noprm.define_singleton_method(:_response) { response }
+        raise noprm, "The bot doesn't have the required permission to do this!"
+      end
 
-          err_klass = OnyxCord::Errors.error_class_for(data['code'] || 0)
-          e = err_klass.new(data['message'], data['errors'])
-          OnyxCord::LOGGER.error(e.full_message)
-          raise e
-        end
-      rescue OnyxCord::Errors::NoPermission => e
-        if e.respond_to?(:_response)
-          response = e._response
-        else
-          OnyxCord::LOGGER.warn("NoPermission doesn't respond_to? _response!")
+      if response.code >= 400 && response.code != 429
+        data = begin
+          JSON.parse(response.body)
+        rescue StandardError
+          nil
         end
 
+        raise "HTTP #{response.code}: #{response.body}" unless data
+
+        err_klass = OnyxCord::Errors.error_class_for(data['code'] || 0)
+        e = err_klass.new(data['message'], data['errors'])
+        OnyxCord::LOGGER.error(e.full_message)
         raise e
-      ensure
-        if response
-          rate_limiter.record_response(key, major_parameter, response.headers)
-        else
-          OnyxCord::LOGGER.ratelimit('Response was nil before trying to preemptively rate limit!')
-        end
       end
-    rescue OnyxCord::Errors::CodeError => e
-      raise if e.respond_to?(:code) && e.code != 429_000
-
-      raise
+    rescue OnyxCord::Errors::NoPermission => e
+      async_rate_limiter.record_response(key, major_parameter, e._response.headers) if e.respond_to?(:_response)
+      raise e
+    else
+      async_rate_limiter.record_response(key, major_parameter, response.headers)
     end
 
-    # Handle 429 rate limiting
-    if response&.code == 429
+    if response.code == 429
       trace("429 #{key} #{major_parameter}")
-      rate_limiter.handle_rate_limit(key, major_parameter, response)
-      return request(key, major_parameter, type, url, body, headers)
+      async_rate_limiter.handle_rate_limit(key, major_parameter, response)
+      return request_async(key, major_parameter, type, url, body, headers)
     end
 
-    # Endpoints that use Elasticsearch can return a 202 when the index isn't ready yet. Wait the
-    # amount of time indicated by the response body, and then recursively retry and return the request.
-    if response&.code == 202 && response&.body
+    if response.code == 202 && response.body
       body_data = JSON.parse(response.body)
 
       if body_data['code'] == 110_000
         case body_data['retry_after']
         when 0, 1, nil
-          sleep(rand(4.5..5.0))
+          OnyxCord::AsyncRuntime.sleep(rand(4.5..5.0))
         else
-          sleep(body_data['retry_after'])
+          OnyxCord::AsyncRuntime.sleep(body_data['retry_after'])
         end
 
-        return request(key, major_parameter, type, url, body, headers)
+        return request_async(key, major_parameter, type, url, body, headers)
       end
     end
 

data/lib/onyxcord/application_commands/command.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module ApplicationCommands
+    class Command
+      attr_reader :name, :description, :type, :attributes, :options, :block
+
+      TYPES = {
+        chat_input: 1,
+        user: 2,
+        message: 3
+      }.freeze
+
+      def self.chat_input(name, description:, **attributes, &block)
+        new(name, description: description, type: :chat_input, **attributes, &block)
+      end
+
+      def self.user(name, **attributes, &block)
+        new(name, description: '', type: :user, **attributes, &block)
+      end
+
+      def self.message(name, **attributes, &block)
+        new(name, description: '', type: :message, **attributes, &block)
+      end
+
+      def initialize(name, description: '', type: :chat_input, **attributes, &block)
+        @name = name.to_s
+        @description = description
+        @type = type
+        @attributes = attributes
+        @options = []
+        @block = block
+        @executor = nil
+        @default_member_permissions = attributes[:default_member_permissions]
+        @nsfw = attributes[:nsfw]
+        @contexts = attributes[:contexts]
+      end
+
+      def parse(&block)
+        instance_eval(&block) if block
+        self
+      end
+
+      def execute(&block)
+        @executor = block
+      end
+
+      def call(context)
+        return unless @executor
+
+        @executor.call(context)
+      end
+
+      def to_h
+        data = {
+          name: @name,
+          type: TYPES[@type] || @type
+        }
+
+        data[:description] = @description if @type == :chat_input
+        data[:options] = @options.map(&:to_h) unless @options.empty?
+        data[:default_member_permissions] = @default_member_permissions if @default_member_permissions
+        data[:nsfw] = @nsfw if @nsfw
+        data[:contexts] = @contexts if @contexts
+
+        data
+      end
+
+      Option::OPTION_METHODS.each do |method_name, option_type|
+        define_method(method_name) do |name, description = '', **attrs, &blk|
+          opt = Option.new(name, description, option_type, **attrs, &blk)
+          @options << opt
+          opt
+        end
+      end
+
+      def subcommand(name, description, &block)
+        sub = Option.new(name, description, :subcommand, &block)
+        @options << sub
+        sub
+      end
+
+      def subcommand_group(name, description, &block)
+        group = Option.new(name, description, :subcommand_group, &block)
+        @options << group
+        group
+      end
+
+      def method_missing(method_name, *args, **kwargs, &block)
+        if @block && @block.arity.positive?
+          @block.call(Context::Proxy.new(self, method_name, args, kwargs, block))
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/onyxcord/application_commands/context.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module ApplicationCommands
+    class Context
+      attr_reader :event, :command
+
+      def initialize(event, command)
+        @event = event
+        @command = command
+      end
+
+      def bot
+        event.bot
+      end
+
+      def user
+        event.user
+      end
+
+      def member
+        event.user
+      end
+
+      def guild
+        event.server
+      end
+
+      def guild_id
+        event.server_id
+      end
+
+      def channel
+        event.channel
+      end
+
+      def channel_id
+        event.channel_id
+      end
+
+      def server
+        event.server
+      end
+
+      def server_id
+        event.server_id
+      end
+
+      def options
+        return {} unless event.data
+
+        if event.data['options']
+          result = {}
+          event.data['options'].each do |opt|
+            key = opt['name'].to_sym
+            result[key] = opt['value']
+          end
+          result
+        else
+          {}
+        end
+      end
+
+      def respond(...)
+        event.respond(...)
+      end
+
+      def defer(...)
+        event.defer(...)
+      end
+
+      def edit_original(...)
+        event.edit_response(...)
+      end
+
+      def delete_original
+        event.delete_response
+      end
+
+      def followup(...)
+        event.send_message(...)
+      end
+
+      class Proxy
+        def initialize(command, method_name, args, kwargs, block)
+          @command = command
+          @method_name = method_name
+          @args = args
+          @kwargs = kwargs
+          @block = block
+        end
+
+        def to_h
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/application_commands/option.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module ApplicationCommands
+    class Option
+      attr_reader :name, :description, :type, :attributes, :options
+
+      OPTION_TYPES = {
+        subcommand: 1,
+        subcommand_group: 2,
+        string: 3,
+        integer: 4,
+        boolean: 5,
+        user: 6,
+        channel: 7,
+        role: 8,
+        mentionable: 9,
+        number: 10,
+        attachment: 11
+      }.freeze
+
+      OPTION_METHODS = OPTION_TYPES.each_with_object({}) do |(name, value), hash|
+        next if %i[subcommand subcommand_group].include?(name)
+
+        hash[name] = value
+      end.freeze
+
+      def initialize(name, description, type, **attributes, &block)
+        @name = name.to_s
+        @description = description
+        @type = type
+        @attributes = attributes
+        @options = []
+        @block = block
+
+        instance_eval(&@block) if @block && type == :subcommand
+      end
+
+      def to_h
+        data = {
+          name: @name,
+          description: @description,
+          type: OPTION_TYPES[@type] || @type
+        }
+
+        data[:required] = @attributes[:required] unless @attributes[:required].nil?
+        data[:min_length] = @attributes[:min_length] if @attributes[:min_length]
+        data[:max_length] = @attributes[:max_length] if @attributes[:max_length]
+        data[:min_value] = @attributes[:min_value] if @attributes[:min_value]
+        data[:max_value] = @attributes[:max_value] if @attributes[:max_value]
+        data[:autocomplete] = @attributes[:autocomplete] unless @attributes[:autocomplete].nil?
+        data[:channel_types] = @attributes[:channel_types] if @attributes[:channel_types]
+
+        if @attributes[:choices]
+          data[:choices] = @attributes[:choices].map do |name, value|
+            { name: name.to_s, value: value }
+          end
+        end
+
+        data[:options] = @options.map(&:to_h) unless @options.empty?
+
+        data
+      end
+
+      def subcommand(name, description, **attrs, &block)
+        sub = Option.new(name, description, :subcommand, **attrs, &block)
+        @options << sub
+        sub
+      end
+
+      OPTION_METHODS.each do |method_name, option_type|
+        define_method(method_name) do |name, description = '', **attrs, &blk|
+          opt = Option.new(name, description, option_type, **attrs, &blk)
+          @options << opt
+          opt
+        end
+      end
+    end
+  end
+end