rubord 0.1.3

data/lib/rubord/structs/logger.rb

@@ -0,0 +1,19 @@
+module Rubord
+  module Logger
+    def self.success(message)
+      puts "\e[32m✔ #{message}\e[0m"
+    end
+
+    def self.info(message)
+      puts "\e[36mℹ #{message}\e[0m"
+    end
+
+    def self.warn(message)
+      puts "\e[33m⚠ #{message}\e[0m"
+    end
+
+    def self.error(message)
+      puts "\e[31m✖ #{message}\e[0m"
+    end
+  end
+end

data/lib/rubord/structs/models.rb

@@ -0,0 +1,19 @@
+require_relative "../models/components"
+require_relative "../models/channel"
+require_relative "../models/embed"
+require_relative "../models/guild"
+require_relative "../models/member"
+require_relative "../models/mention"
+require_relative "../models/message"
+require_relative "../models/role"
+require_relative "../models/user"
+require_relative "../models/collection"
+require_relative "../models/flags"
+require_relative "../models/interaction"
+require_relative "../models/commands/command.rb"
+require_relative "logger.rb"
+
+module Rubord
+  class GatewayError < StandardError; end
+  class InvalidTokenError < GatewayError; end
+end

data/lib/rubord/structs/parser.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+COLORS = {
+  red:        "#ED4245",
+  orange:     "#FEE75C",
+  yellow:     "#F1C40F",
+  green:      "#57F287",
+  teal:       "#1ABC9C",
+  blue:       "#3498DB",
+  blurple:    "#5865F2",
+  purple:     "#9B59B6",
+  pink:       "#EB459E",
+  white:      "#FFFFFF",
+  gray:       "#95A5A6",
+  dark_gray:  "#2C2F33",
+  black:      "#000000"
+}.freeze
+
+module Rubord
+  class Parser
+    CHANNEL_MENTION_REGEX = /<#(\d{17,22})>/.freeze
+
+    def timestamp(value)
+      return value if value.is_a?(Time)
+      return nil unless value
+
+      Time.parse(value.to_s)
+    rescue ArgumentError
+      nil
+    end
+
+    def color(value)
+      return nil if value.nil?
+
+      case value
+      when Symbol
+        hex_to_int(COLORS[value])
+      when String
+        if COLORS.key?(value.to_sym)
+          hex_to_int(COLORS[value.to_sym])
+        else
+          hex_to_int(value)
+        end
+      else
+        value.to_i
+      end
+    end
+
+    def channel_mentions(text)
+      return [] unless text
+
+      text.scan(CHANNEL_MENTION_REGEX).flatten.map(&:to_i)
+    end
+
+    private
+
+    def hex_to_int(hex)
+      return nil unless hex
+
+      hex = hex.delete_prefix("#")
+      hex.to_i(16)
+    end
+  end
+
+  def self.Parser
+    @parser ||= Parser.new
+  end
+end

data/lib/rubord/structs/rate_limiter.rb

@@ -0,0 +1,163 @@
+module Rubord
+  class RateLimiter
+    class Bucket
+      attr_reader :id, :limit, :remaining, :reset_at, :queue, :last_request_at
+
+      def initialize(id)
+        @id = id
+        @limit = 1
+        @remaining = 1
+        @reset_at = Time.now
+        @queue = []
+        @last_request_at = nil
+        @mutex = Mutex.new
+      end
+
+      def available?
+        @mutex.synchronize do
+          now = Time.now
+          
+          if now >= @reset_at
+            @remaining = @limit
+            @reset_at = now + 1
+          end
+          
+          @remaining > 0
+        end
+      end
+
+      def wait
+        @mutex.synchronize do
+          now = Time.now
+          
+          if now < @reset_at && @remaining <= 0
+            sleep_time = @reset_at - now
+            sleep(sleep_time) if sleep_time > 0
+            @remaining = @limit
+          end
+        end
+      end
+
+      def update_from_headers(headers)
+        @mutex.synchronize do
+          limit_header = headers["x-ratelimit-limit"]
+          remaining_header = headers["x-ratelimit-remaining"]
+          reset_after_header = headers["x-ratelimit-reset-after"]
+          reset_header = headers["x-ratelimit-reset"]
+          
+          limit_value = Array(limit_header).first
+          remaining_value = Array(remaining_header).first
+          reset_after_value = Array(reset_after_header).first
+          reset_value = Array(reset_header).first
+          
+          @limit = limit_value&.to_i || @limit
+          @remaining = remaining_value&.to_i || @remaining
+          
+          if reset_after_value
+            @reset_at = Time.now + reset_after_value.to_f
+          elsif reset_value
+            @reset_at = Time.at(reset_value.to_i)
+          end
+          
+          @last_request_at = Time.now
+        end
+      end
+
+      def reset_in
+        [0, @reset_at - Time.now].max
+      end
+    end
+
+    class GlobalLimiter
+      def initialize
+        @reset_at = Time.now
+        @mutex = Mutex.new
+      end
+
+      def blocked?
+        @mutex.synchronize { Time.now < @reset_at }
+      end
+
+      def block_for(seconds)
+        @mutex.synchronize do
+          @reset_at = Time.now + seconds
+        end
+      end
+
+      def wait
+        @mutex.synchronize do
+          if Time.now < @reset_at
+            sleep_time = @reset_at - Time.now
+            sleep(sleep_time) if sleep_time > 0
+          end
+        end
+      end
+    end
+
+    def initialize
+      @buckets = {}
+      @route_buckets = {}
+      @global_limiter = GlobalLimiter.new
+      @mutex = Mutex.new
+      @default_bucket = Bucket.new("default")
+    end
+
+    def bucket_for(route)
+      @mutex.synchronize do
+        bucket_id = @route_buckets[route]
+        
+        if bucket_id
+          @buckets[bucket_id] ||= Bucket.new(bucket_id)
+        else
+          @default_bucket
+        end
+      end
+    end
+
+    def update_mapping(route, bucket_id)
+      @mutex.synchronize do
+        @route_buckets[route] = bucket_id
+        @buckets[bucket_id] ||= Bucket.new(bucket_id)
+      end
+    end
+
+    def wait_global
+      @global_limiter.wait
+    end
+
+    def wait_for(route)
+      bucket = bucket_for(route)
+      bucket.wait
+    end
+
+    def handle_rate_limit(headers, body)
+      if body["global"] == true
+        @global_limiter.block_for(body["retry_after"])
+        return :global
+      else
+        bucket_header = headers["x-ratelimit-bucket"]
+        bucket_id = Array(bucket_header).first if bucket_header
+        
+        if bucket_id
+          @mutex.synchronize do
+            @buckets[bucket_id] ||= Bucket.new(bucket_id)
+            @buckets[bucket_id].reset_at = Time.now + body["retry_after"]
+            @buckets[bucket_id].remaining = 0
+          end
+        end
+        return :route
+      end
+    end
+
+    def update_bucket(route, headers)
+      bucket_header = headers["x-ratelimit-bucket"]
+      bucket_id = Array(bucket_header).first if bucket_header
+      return unless bucket_id
+
+      update_mapping(route, bucket_id)
+      
+      bucket = @buckets[bucket_id]
+      bucket.update_from_headers(headers)
+    end
+  end
+end

data/lib/rubord/structs/rest.rb

@@ -0,0 +1,353 @@
+require "net/http"
+require "uri"
+require "openssl"
+require "json"
+require_relative "rate_limiter"
+
+if ENV["TERMUX_VERSION"]
+  OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:verify_mode] =
+    OpenSSL::SSL::VERIFY_PEER
+
+  OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:verify_callback] =
+    proc do |preverify_ok, ssl_ctx|
+      return true if preverify_ok
+
+      ssl_ctx.error == OpenSSL::X509::V_ERR_UNABLE_TO_GET_CRL
+    end
+end
+
+module Rubord
+  class REST
+    BASE_URL = "https://discord.com/api/v10"
+    
+    # Default retry configuration
+    MAX_RETRIES = 3
+    INITIAL_RETRY_DELAY = 0.5
+
+    def initialize(token)
+      @token = token
+      @rate_limiter = RateLimiter.new
+      @http_pool = {} # Simple HTTP connection pool
+    end
+
+    # ========== MÉTODOS PÚBLICOS DA API ==========
+    
+    def send_message(channel_id, **opts)
+      body = build_message_body(**opts)
+      request(:post, "/channels/#{channel_id}/messages", body: body)
+    end
+
+    def reply_message(channel_id, message_id, **opts)
+      body = build_message_body(**opts)
+      body[:message_reference] = {
+        message_id: message_id,
+        channel_id: channel_id
+      }
+      request(:post, "/channels/#{channel_id}/messages", body: body)
+    end
+
+    def edit_message(channel_id, message_id, **opts)
+      body = build_message_body(**opts)
+      request(:patch, "/channels/#{channel_id}/messages/#{message_id}", body: body)
+    end
+
+    def delete_message(channel_id, message_id)
+      request(:delete, "/channels/#{channel_id}/messages/#{message_id}")
+    end
+
+    def get_channel(channel_id)
+      request(:get, "/channels/#{channel_id}")
+    end
+
+    def get_message(channel_id, message_id)
+      request(:get, "/channels/#{channel_id}/messages/#{message_id}")
+    end
+
+    def get_user(user_id)
+      request(:get, "/users/#{user_id}")
+    end
+
+    def get_guild(guild_id)
+      request(:get, "/guilds/#{guild_id}")
+    end
+
+    def get_guild_member(guild_id, user_id)
+      request(:get, "/guilds/#{guild_id}/members/#{user_id}")
+    end
+
+    def kick_guild_member(guild_id, user_id, reason: nil)
+      path = "/guilds/#{guild_id}/members/#{user_id}"
+      path += "?reason=#{URI.encode(reason)}" if reason
+      request(:delete, path)
+    end
+
+    def ban_guild_member(guild_id, user_id, delete_message_days: 0, reason: nil)
+      path = "/guilds/#{guild_id}/bans/#{user_id}?delete_message_days=#{delete_message_days}"
+      path += "&reason=#{URI.encode(reason)}" if reason
+      request(:put, path)
+    end
+
+    def unban_guild_member(guild_id, user_id, reason: nil)
+      path = "/guilds/#{guild_id}/bans/#{user_id}"
+      path += "?reason=#{URI.encode(reason)}" if reason
+      request(:delete, path)
+    end
+
+    def get_application
+      request(:get, "/oauth2/applications/@me")
+    end
+
+    def interactions_response(interaction_id, interaction_token, type:, data: nil)
+      body = { type: type }
+      body[:data] = data if data
+      request(:post, "/interactions/#{interaction_id}/#{interaction_token}/callback", body: body)
+    end
+
+    def interaction_edit(application_id, token, **opts)
+      body = build_message_body(**opts)
+      request(:patch, "/webhooks/#{application_id}/#{token}/messages/@original", body: body)
+    end
+
+    def interaction_followup(application_id, token, **opts)
+      body = build_message_body(**opts)
+      request(:post, "/webhooks/#{application_id}/#{token}", body: body)
+    end
+
+    def build_message_body(content: nil, embeds: nil, components: nil, flags: nil)
+      body = {}
+
+      resolved_flags =
+        case flags
+        when Array
+          Rubord::MessageFlags.combine(*flags)
+        when Symbol
+          Rubord::MessageFlags.combine(flags)
+        when Integer
+          flags
+        else
+          nil
+        end
+
+      is_components_v2 =
+        resolved_flags &&
+        (resolved_flags & Rubord::MessageFlags::COMPONENTS_V2 != 0)
+
+      if is_components_v2
+        if content || embeds
+          raise ArgumentError, "content/embeds cannot be used with Components V2. Use Rubord::Text or other components."
+        end
+      else
+        body[:content] = content if content
+        body[:embeds]  = Array(embeds).map(&:to_h) if embeds
+      end
+
+      body[:components] = Array(components).map(&:to_h) if components
+      body[:flags]      = resolved_flags if resolved_flags
+
+      body
+    end
+
+    def handle_response(res)
+      parse_response(res)
+    end
+
+    # ========== MÉTODO REQUEST PÚBLICO ==========
+    
+    def request(method, path, body: nil, retries: MAX_RETRIES)
+      route = extract_route(method, path)
+      uri = URI("#{BASE_URL}#{path}")
+      
+      # Wait for rate limits
+      @rate_limiter.wait_global
+      @rate_limiter.wait_for(route)
+      
+      req = build_request(method, uri)
+      req.body = JSON.generate(body) if body
+
+      begin
+        res = send_http_request(uri, req)
+        
+        # Handle rate limit responses
+        if res.code.to_i == 429
+          return handle_rate_limit_response(res, route, method, path, body, retries)
+        end
+        
+        # Handle other errors
+        unless res.is_a?(Net::HTTPSuccess)
+          raise_api_error(res)
+        end
+        
+        # Update rate limit info
+        update_rate_limit_info(route, res)
+        
+        # Parse and return response
+        return parse_response(res)
+        
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        return handle_timeout(e, method, path, body, retries)
+      rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH => e
+        return handle_connection_error(e, method, path, body, retries)
+      rescue => e
+        # Handle any other unexpected errors
+        puts "[REST Error] Unexpected error: #{e.class}: #{e.message}"
+        raise e
+      end
+    end
+
+    # ========== MÉTODOS PRIVADOS ==========
+    private
+
+    # Extract route identifier for rate limiting
+    def extract_route(method, path)
+      # Remove IDs from path for better bucket matching
+      clean_path = path.gsub(/\d+/, ":id")
+      "#{method.upcase}:#{clean_path}"
+    end
+
+    # Send HTTP request with connection pooling
+    def send_http_request(uri, req)
+      http = @http_pool[uri.host] ||= Net::HTTP.new(uri.hostname, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.read_timeout = 30
+      http.open_timeout = 10
+      
+      http.start unless http.started?
+      http.request(req)
+    end
+
+    # Handle rate limit response (429)
+    def handle_rate_limit_response(res, route, method, path, body, retries)
+      retry_after = extract_retry_after(res)
+      is_global = parse_rate_limit_body(res).fetch("global", false)
+      
+      puts "[Rate Limit] #{is_global ? 'Global' : 'Route'} rate limit hit on #{route}. Waiting #{retry_after}s"
+      
+      if is_global
+        @rate_limiter.handle_rate_limit(res.to_hash, parse_rate_limit_body(res))
+      end
+      
+      sleep(retry_after)
+      
+      # Retry the request
+      if retries > 0
+        return request(method, path, body: body, retries: retries - 1)
+      else
+        raise "Rate limit retries exhausted for #{route}"
+      end
+    end
+
+    # Update rate limit information from successful response
+    def update_rate_limit_info(route, res)
+      headers = res.to_hash.transform_keys(&:downcase)
+      @rate_limiter.update_bucket(route, headers)
+    end
+
+    # Parse response body
+    def parse_response(res)
+      return nil if res.body.nil? || res.body.empty?
+      
+      JSON.parse(res.body)
+    rescue JSON::ParserError
+      res.body
+    end
+
+    # Extract retry-after time from response
+    def extract_retry_after(res)
+      body = parse_rate_limit_body(res)
+      
+      # Try from body first, then header
+      retry_after = body["retry_after"] if body.is_a?(Hash)
+      retry_after ||= res["retry-after"] || res["Retry-After"]
+      retry_after ||= 1.0
+      
+      retry_after.to_f
+    end
+
+    # Parse rate limit response body
+    def parse_rate_limit_body(res)
+      return {} if res.body.nil? || res.body.empty?
+      
+      begin
+        JSON.parse(res.body)
+      rescue JSON::ParserError
+        {}
+      end
+    end
+
+    # Handle timeout errors with retry
+    def handle_timeout(error, method, path, body, retries)
+      puts "[Timeout] #{error.message} for #{method} #{path}"
+      
+      if retries > 0
+        sleep(INITIAL_RETRY_DELAY * (MAX_RETRIES - retries + 1))
+        return request(method, path, body: body, retries: retries - 1)
+      else
+        raise "Request timeout after #{MAX_RETRIES} retries"
+      end
+    end
+
+    def handle_connection_error(error, method, path, body, retries)
+      puts "[Connection Error] #{error.class}: #{error.message}"
+      
+      @http_pool.clear
+      
+      if retries > 0
+        sleep(1 * (MAX_RETRIES - retries + 1))
+        return request(method, path, body: body, retries: retries - 1)
+      else
+        raise "Connection failed after #{MAX_RETRIES} retries"
+      end
+    end
+
+    def raise_api_error(res)
+      body = parse_response(res) || {}
+      message = body["message"] || res.message || "HTTP #{res.code}"
+      
+      error_class = case res.code.to_i
+                   when 400 then BadRequestError
+                   when 401 then UnauthorizedError
+                   when 403 then ForbiddenError
+                   when 404 then NotFoundError
+                   when 429 then RateLimitError
+                   when 500..599 then ServerError
+                   else APIError
+                   end
+      
+      raise error_class.new(message, res.code.to_i, body)
+    end
+
+    # Build HTTP request
+    def build_request(method, uri)
+      klass = {
+        get:    Net::HTTP::Get,
+        post:   Net::HTTP::Post,
+        put:    Net::HTTP::Put,
+        patch:  Net::HTTP::Patch,
+        delete: Net::HTTP::Delete
+      }.fetch(method)
+
+      req = klass.new(uri)
+      req["Authorization"] = "Bot #{@token}"
+      req["Content-Type"]  = "application/json"
+      req["User-Agent"]    = "DiscordBot (https://github.com/kauzxx00/rubord, 1.0.0)"
+      req
+    end
+  end
+
+  class APIError < StandardError
+    attr_reader :status, :response_body
+    
+    def initialize(message, status = nil, response_body = nil)
+      super(message)
+      @status = status
+      @response_body = response_body
+    end
+  end
+  
+  class BadRequestError < APIError; end
+  class UnauthorizedError < APIError; end
+  class ForbiddenError < APIError; end
+  class NotFoundError < APIError; end
+  class RateLimitError < APIError; end
+  class ServerError < APIError; end
+end

data/lib/rubord.rb

@@ -0,0 +1,8 @@
+require "json"
+require_relative "rubord/structs/client"
+require_relative "rubord/structs/models"
+require_relative "rubord/structs/parser"
+
+module Rubord
+  VERSION = "0.1.3"
+end