onyxcord 2.1.0 → 3.2.1

data/lib/onyxcord/http.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require 'httpx'
-require 'net/http'
-require 'onyxcord/json'
-require 'onyxcord/upload'
-require 'securerandom'
-require 'uri'
-
-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.respond_to?(:status) ? httpx_response.status : httpx_response.code.to_i
-        response_headers = httpx_response.respond_to?(:headers) ? httpx_response.headers : httpx_response.to_hash
-        @headers = normalize_headers(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.transform_values do |value|
-          value.is_a?(Array) && value.size == 1 ? value.first : value
-        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)
-                                                 .with(
-                                                   fallback_protocol: 'http/1.1',
-                                                   ssl: { alpn_protocols: ['http/1.1'] }
-                                                 )
-    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 multipart?(body)
-                # Multipart upload
-                post_multipart(url, body, headers)
-              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
-
-    def post_multipart(url, body, headers)
-      uri = URI(url)
-      boundary = "----OnyxCord#{SecureRandom.hex(12)}"
-      request = Net::HTTP::Post.new(uri)
-      headers.each { |key, value| request[key.to_s] = value }
-      request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
-      request.body = multipart_body(body, boundary)
-
-      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
-        http.request(request)
-      end
-    end
-
-    def multipart_body(body, boundary)
-      output = String.new.b
-
-      multipart_parts(body).each do |part|
-        key = part[:name]
-        value = part[:value]
-        output << "--#{boundary}\r\n"
-        if part[:filename]
-          value.rewind if value.respond_to?(:rewind)
-          filename = part[:filename]
-          output << "Content-Disposition: form-data; name=\"#{key}\"; filename=\"#{filename}\"\r\n"
-          output << "Content-Type: #{part[:content_type] || multipart_content_type(filename)}\r\n\r\n"
-          output << value.read.to_s
-        else
-          output << "Content-Disposition: form-data; name=\"#{key}\"\r\n"
-          output << "\r\n"
-          output << value.to_s
-        end
-        output << "\r\n"
-      end
-
-      output << "--#{boundary}--\r\n"
-    end
-
-    def multipart_content_type(filename)
-      File.extname(filename).casecmp('.txt').zero? ? 'text/plain' : 'application/octet-stream'
-    end
-
-    def multipart?(body)
-      return true if body.is_a?(Array) && body.all? { |part| part.is_a?(Hash) && part[:name] && part.key?(:value) }
-
-      body.is_a?(Hash) && body.any? { |_, value| value.respond_to?(:read) || value.respond_to?(:path) }
-    end
-
-    def multipart_parts(body)
-      return body if body.is_a?(Array)
-
-      body.map do |key, value|
-        if value.respond_to?(:read) || value.respond_to?(:path)
-          upload = OnyxCord::Upload.wrap(value)
-          { name: key, value: upload, filename: upload.filename, content_type: upload.content_type }
-        else
-          { name: key, value: value }
-        end
-      end
-    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,150 +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(@global_lock)
-        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)
-        async_wait(time, @global_lock)
-      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.1.0'
-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