onyxcord 2.0.13 → 3.2.0

data/lib/onyxcord/http.rb

@@ -1,115 +0,0 @@
-# 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 for the current thread.
-    def session
-      Thread.current[:onyxcord_http_session] ||= HTTPX.plugin(:persistent)
-                                                 .plugin(:follow_redirects)
-    end
-
-    # Reset the HTTP session (useful for tests).
-    def reset!
-      Thread.current[:onyxcord_http_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

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

data/lib/onyxcord/rate_limiter/async_rest.rb

@@ -1,149 +0,0 @@
-# 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/rate_limiter/gateway.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module OnyxCord
-  module RateLimiter
-    # Sliding-window limiter for Gateway sends.
-    class Gateway
-      DEFAULT_LIMIT = 120
-      DEFAULT_INTERVAL = 60
-
-      def initialize(limit: DEFAULT_LIMIT, interval: DEFAULT_INTERVAL, clock: -> { Time.now }, sleeper: ->(duration) { sleep(duration) })
-        @limit = limit
-        @interval = interval
-        @clock = clock
-        @sleeper = sleeper
-        @sent_at = []
-        @mutex = Mutex.new
-      end
-
-      def wait
-        @mutex.synchronize do
-          now = @clock.call
-          prune(now)
-
-          if @sent_at.length >= @limit
-            sleep_for = @interval - (now - @sent_at.first)
-            @sleeper.call(sleep_for) if sleep_for.positive?
-            now = @clock.call
-            prune(now)
-          end
-
-          @sent_at << now
-        end
-      end
-
-      private
-
-      def prune(now)
-        @sent_at.shift while @sent_at.any? && (now - @sent_at.first) >= @interval
-      end
-    end
-  end
-end

data/lib/onyxcord/rate_limiter/rest.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-require 'onyxcord/json'
-
-module OnyxCord
-  module RateLimiter
-    # Discord REST rate limiter keyed by route/major parameter and remapped to
-    # X-RateLimit-Bucket whenever Discord returns a concrete bucket id.
-    class Rest
-      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_mutexes = {}
-        @bucket_last_used = {}
-        @global_mutex = Mutex.new
-        @clock = clock
-        @entry_ttl = entry_ttl
-        @prune_interval = prune_interval
-        @requests_since_prune = 0
-      end
-
-      def before_request(route, major_parameter)
-        mutex_wait(mutex_for(route, major_parameter))
-        mutex_wait(@global_mutex) if @global_mutex.locked?
-      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?
-
-        sync_wait(wait_seconds, mutex_for(route, major_parameter))
-      end
-
-      def handle_rate_limit(route, major_parameter, response)
-        headers = normalize_headers(response.headers)
-        mutex = headers[:x_ratelimit_global] == 'true' || headers[:x_ratelimit_scope] == 'global' ? @global_mutex : mutex_for(route, major_parameter)
-        wait_seconds = retry_after(response, headers)
-
-        sync_wait(wait_seconds, mutex) if wait_seconds.positive?
-      end
-
-      def stats
-        {
-          route_buckets: @route_buckets.size,
-          bucket_mutexes: @bucket_mutexes.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_mutexes.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_mutexes[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 sync_wait(time, mutex)
-        mutex.synchronize { sleep time }
-      end
-
-      def mutex_wait(mutex)
-        mutex.lock
-        mutex.unlock
-      end
-    end
-  end
-end

data/lib/onyxcord/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-# OnyxCord and all its functionality, in this case only the version.
-module OnyxCord
-  # The current version of onyxcord.
-  VERSION = '2.0.13'
-end

data/lib/onyxcord/websocket.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'onyxcord/async/runtime'
-require 'async/http/endpoint'
-require 'async/http/protocol/http11'
-require 'async/websocket/client'
-
-module OnyxCord
-  class WebSocket
-    attr_reader :connected
-
-    alias_method :connected?, :connected
-
-    def initialize(host, open_handler, message_handler, error_handler, close_handler)
-      @host = host
-      @open_handler = open_handler
-      @message_handler = message_handler
-      @error_handler = error_handler
-      @close_handler = close_handler
-
-      @connection = nil
-      @connected = false
-
-      connect
-    end
-
-    def send(data)
-      return unless @connection
-
-      data = data.to_json if data.is_a?(Hash)
-      @connection.write(Protocol::WebSocket::TextMessage.generate(data))
-      @connection.flush
-    rescue StandardError => e
-      @error_handler&.call(e)
-    end
-
-    def close
-      @connected = false
-      @connection&.close
-    rescue StandardError
-      # Ignore errors on close
-    end
-
-    private
-
-    def connect
-      endpoint = websocket_endpoint(@host)
-
-      @task = OnyxCord::AsyncRuntime.async do
-        Async::WebSocket::Client.connect(endpoint, extensions: nil) do |connection|
-          @connection = connection
-          @connected = true
-          @open_handler&.call
-
-          while (message = connection.read)
-            @message_handler&.call(message.to_str)
-          end
-        rescue StandardError => e
-          @error_handler&.call(e)
-        ensure
-          @connected = false
-          @close_handler&.call(nil)
-        end
-      end
-    rescue StandardError => e
-      @error_handler&.call(e)
-    end
-
-    def websocket_endpoint(url)
-      Async::HTTP::Endpoint.parse(
-        url,
-        protocol: Async::HTTP::Protocol::HTTP11,
-        alpn_protocols: ['http/1.1']
-      )
-    end
-  end
-end

data/onyxcord.gemspec

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/onyxcord/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'onyxcord'
-  spec.version       = OnyxCord::VERSION
-  spec.authors       = ['Gustavo Silva']
-  spec.email         = ['gustavosilva8kt@gmail.com']
-
-  spec.summary       = 'Discord API for Ruby with Components V2 support'
-  spec.description   = 'OnyxCord is a Ruby Discord API library with Components V2, modern modals, raw-first events, and community support: https://discord.gg/Jy2tpCUtzM.'
-  spec.homepage      = 'https://github.com/kruldevb/OnyxCord'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|examples)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.metadata = {
-    'bug_tracker_uri' => 'https://github.com/kruldevb/OnyxCord/issues',
-    'changelog_uri' => 'https://github.com/kruldevb/OnyxCord/blob/main/CHANGELOG.md',
-    'documentation_uri' => 'https://github.com/kruldevb/OnyxCord#readme',
-    'source_code_uri' => 'https://github.com/kruldevb/OnyxCord',
-    'rubygems_mfa_required' => 'true'
-  }
-  spec.require_paths = ['lib']
-
-  # Modern async runtime & networking
-  spec.add_dependency 'async', '>= 2.0', '< 3'
-  spec.add_dependency 'async-http', '>= 0.75', '< 1'
-  spec.add_dependency 'async-websocket', '>= 0.26', '< 1'
-
-  # HTTP client (modern, HTTP/2, persistent connections)
-  spec.add_dependency 'httpx', '>= 1.0', '< 2'
-
-  # Fast JSON parsing
-  spec.add_dependency 'oj', '>= 3.0', '< 4'
-
-  # Smart LRU caching
-  spec.add_dependency 'lru_redux', '>= 1.0', '< 2'
-
-  # Core dependencies
-  spec.add_dependency 'base64', '~> 0.2'
-  spec.add_dependency 'mime-types', '~> 3.0'
-
-  # Voice support
-  spec.add_dependency 'ffi', '>= 1.9.24', '< 2'
-  spec.add_dependency 'opus-ruby', '>= 0', '< 2'
-
-  spec.required_ruby_version = '>= 3.4'
-
-  spec.add_development_dependency 'bundler', '>= 1.10', '< 5'
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'redcarpet', '~> 3.5' # YARD markdown formatting
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rspec_junit_formatter', '~> 0.6.0'
-  spec.add_development_dependency 'rspec-prof', '~> 0.0.7'
-  spec.add_development_dependency 'rubocop', '~> 1.77.0'
-  spec.add_development_dependency 'rubocop-performance', '~> 1.25.0'
-  spec.add_development_dependency 'rubocop-rake', '~> 0.7.0'
-  spec.add_development_dependency 'simplecov', '~> 0.21'
-  spec.add_development_dependency 'yard', '~> 0.9.37'
-end