onyxcord 2.0.5 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e5d5e025fe9ad9abb42d0fca6da5fe8bf9f32bfbe527de27a2da742bfe5f262
-  data.tar.gz: e7b494fd1d4821c2c517f24ceca4a6da27720f552618b71f5a5452c5a3ef915b
+  metadata.gz: c794e2e7f5ad51dea52e27c049fb7d08fb7b54c84b452243fe549cd54f46dd5d
+  data.tar.gz: 2f7e1a9df9cf56085e31dd7bc13e843f8c5bee2e9083817305e6936117c92dd4
 SHA512:
-  metadata.gz: '059ec009fb6fd52704a2906bdfc8fb6a20f0e06dd2ac783e1f466ce4cfabbe71c2fa9cb269a332e69fc3a05cdef7d8e394cfc3a3e1bfb11c94c0c7d43c0dd26d'
-  data.tar.gz: c4f5fb863ec9a636d4b7591b50afe16d4a0174c28390f5d42aa84f7ff32a2e904cfe71de4104b4425a7661cb82e71a9b114abc6b874888c52d8ad74683f14d58
+  metadata.gz: dce8555d60a8bf6662bfc357c64918e75ff803ab30c43c93dab390756ee52e0057f20914367ec4cce89e5a6906c0745f99b89f42953bb9b91648caa3fe296378
+  data.tar.gz: 7b25cd2d344182abbdce7fb5f74f8cffb7dea3ad478d6a03e9018ea138635fac13e9203184f656f677c39b85b26f1a8287f24ac6a855b5b9ae64ec12165e8c72

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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)

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

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/rate_limiter/async_rest.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'onyxcord/async/runtime'
+
+module OnyxCord
+  module RateLimiter
+    class AsyncRest
+      DEFAULT_ENTRY_TTL = 3600
+      DEFAULT_PRUNE_INTERVAL = 100
+
+      def initialize(clock: -> { Time.now }, entry_ttl: DEFAULT_ENTRY_TTL, prune_interval: DEFAULT_PRUNE_INTERVAL)
+        @route_buckets = {}
+        @bucket_locks = {}
+        @bucket_last_used = {}
+        @global_lock = Mutex.new
+        @clock = clock
+        @entry_ttl = entry_ttl
+        @prune_interval = prune_interval
+        @requests_since_prune = 0
+      end
+
+      def before_request(route, major_parameter)
+        wait_for(mutex_for(route, major_parameter))
+      end
+
+      def record_response(route, major_parameter, headers)
+        headers = normalize_headers(headers)
+        bucket = headers[:x_ratelimit_bucket]
+        key = route_key(route, major_parameter)
+        touch(key)
+
+        if bucket
+          bucket = bucket_key(bucket, major_parameter)
+          @route_buckets[key] = bucket
+          touch(bucket)
+        end
+
+        return unless headers[:x_ratelimit_remaining] == '0'
+
+        wait_seconds = headers[:x_ratelimit_reset_after].to_f
+        return unless wait_seconds.positive?
+
+        async_wait(wait_seconds, mutex_for(route, major_parameter))
+      end
+
+      def handle_rate_limit(route, major_parameter, response)
+        headers = normalize_headers(response.headers)
+        wait_seconds = retry_after(response, headers)
+
+        return unless wait_seconds.positive?
+
+        if headers[:x_ratelimit_global] == 'true' || headers[:x_ratelimit_scope] == 'global'
+          global_wait(wait_seconds)
+        else
+          async_wait(wait_seconds, mutex_for(route, major_parameter))
+        end
+      end
+
+      def stats
+        {
+          route_buckets: @route_buckets.size,
+          bucket_locks: @bucket_locks.size,
+          tracked_keys: @bucket_last_used.size
+        }
+      end
+
+      def prune!
+        return 0 unless @entry_ttl
+
+        cutoff = @clock.call - @entry_ttl
+        stale_keys = @bucket_last_used.select { |_, last_used| last_used < cutoff }.keys
+
+        stale_keys.each do |key|
+          @bucket_locks.delete(key)
+          @bucket_last_used.delete(key)
+          @route_buckets.delete(key)
+          @route_buckets.delete_if { |_, bucket_key| bucket_key == key }
+        end
+
+        @requests_since_prune = 0
+        stale_keys.length
+      end
+
+      private
+
+      def mutex_for(route, major_parameter)
+        key = resolved_key(route, major_parameter)
+        touch(key)
+        @bucket_locks[key] ||= Mutex.new
+      end
+
+      def resolved_key(route, major_parameter)
+        @route_buckets[route_key(route, major_parameter)] || route_key(route, major_parameter)
+      end
+
+      def route_key(route, major_parameter)
+        [route, major_parameter].freeze
+      end
+
+      def bucket_key(bucket, major_parameter)
+        [:bucket, bucket, major_parameter].freeze
+      end
+
+      def retry_after(response, headers)
+        body = response.respond_to?(:body) ? response.body : response.to_s
+        if body && !body.empty?
+          data = JSON.parse(body)
+          return data['retry_after'].to_f if data['retry_after']
+        end
+
+        (headers[:retry_after] || 0).to_f
+      rescue JSON::ParserError
+        (headers[:retry_after] || 0).to_f
+      end
+
+      def normalize_headers(headers)
+        headers.each_with_object({}) do |(key, value), memo|
+          memo[key.to_s.tr('-', '_').downcase.to_sym] = value.to_s
+        end
+      end
+
+      def touch(key)
+        @bucket_last_used[key] = @clock.call
+        prune_if_needed
+      end
+
+      def prune_if_needed
+        return unless @prune_interval
+
+        @requests_since_prune += 1
+        prune! if @requests_since_prune >= @prune_interval
+      end
+
+      def wait_for(mutex)
+        mutex.lock
+        mutex.unlock
+      end
+
+      def async_wait(time, mutex)
+        mutex.synchronize { OnyxCord::AsyncRuntime.sleep(time) }
+      end
+
+      def global_wait(time)
+        OnyxCord::AsyncRuntime.sleep(time)
+      end
+    end
+  end
+end

data/lib/onyxcord/version.rb

@@ -3,5 +3,5 @@
 # OnyxCord and all its functionality, in this case only the version.
 module OnyxCord
   # The current version of onyxcord.
-  VERSION = '2.0.5'
+  VERSION = '2.0.6'
 end

data/lib/onyxcord/webhooks/version.rb

@@ -4,6 +4,6 @@
 module OnyxCord
   module Webhooks
     # The current version of onyxcord-webhooks.
-    VERSION = '2.0.0'
+    VERSION = '2.0.6'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: onyxcord
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 2.0.6
 platform: ruby
 authors:
 - Gustavo Silva
@@ -396,6 +396,12 @@ files:
 - lib/onyxcord/api/server.rb
 - lib/onyxcord/api/user.rb
 - lib/onyxcord/api/webhook.rb
+- lib/onyxcord/application_commands.rb
+- lib/onyxcord/application_commands/command.rb
+- lib/onyxcord/application_commands/context.rb
+- lib/onyxcord/application_commands/option.rb
+- lib/onyxcord/application_commands/registry.rb
+- lib/onyxcord/async/runtime.rb
 - lib/onyxcord/await.rb
 - lib/onyxcord/bot.rb
 - lib/onyxcord/cache.rb
@@ -482,6 +488,7 @@ files:
 - lib/onyxcord/message_components.rb
 - lib/onyxcord/paginator.rb
 - lib/onyxcord/permissions.rb
+- lib/onyxcord/rate_limiter/async_rest.rb
 - lib/onyxcord/rate_limiter/gateway.rb
 - lib/onyxcord/rate_limiter/rest.rb
 - lib/onyxcord/version.rb