rubord 0.1.3

data/lib/rubord/structs/client.rb

@@ -0,0 +1,364 @@
+require_relative "rest"
+require_relative "gateway"
+
+
+module Rubord
+  # Main client class for interacting with the Discord API.
+  #
+  # The Client serves as the primary interface for creating Discord bots
+  # and managing connections to the Discord Gateway and REST API.
+  #
+  # @example Creating a basic bot client
+  #   client = Rubord::Client.new(prefix: "!", intents: [:messages])
+  #   client.login("YOUR_BOT_TOKEN")
+  #
+  #   client.on(:ready) do |user|
+  #     puts "Logged in as #{user.username}"
+  #   end
+  #
+  #   client.on(:message_create) do |message|
+  #     if message.content.start_with?("!ping")
+  #       message.reply("Pong!")
+  #     end
+  #   end
+  #
+  # @since 1.0.0
+  # @see https://discord.com/developers/docs Discord Developer Documentation
+  class Client
+    # @return [Rubord::REST] The REST API client instance.
+    attr_reader :rest
+    
+    # @return [Rubord::Gateway] The WebSocket gateway connection instance.
+    attr_reader :gateway
+    
+    # @return [Rubord::Collection] Collection of cached messages.
+    attr_reader :messages
+    
+    # @return [Rubord::Collection] Collection of cached channels.
+    attr_reader :channels
+    
+    # @return [Integer] Bitwise value representing enabled Discord intents.
+    attr_reader :intents
+    
+    # @return [String] Command prefix for message-based commands.
+    attr_reader :prefix
+    
+    # @return [Rubord::User, nil] The bot user account, available after login.
+    attr_reader :user
+    
+    # @return [Rubord::Collection] Collection of cached users.
+    attr_reader :users
+    
+    # @return [Rubord::Collection] Collection of cached guilds (servers).
+    attr_reader :guilds
+
+    # @return [Rubord::Commands] Commands for the bot.
+    attr_reader :commands
+
+    # Initializes a new Discord client instance.
+    #
+    # @param prefix [String] The command prefix for message commands.
+    #   Default is empty string (no prefix required).
+    # @param intents [Array<Symbol, Integer>] Discord intents to enable.
+    #   Can be symbols (e.g., `:guilds`, `:messages`) or integer bit values.
+    #
+    # @example With prefix and intents
+    #   client = Rubord::Client.new(
+    #     prefix: "!",
+    #     intents: [:guilds, :guild_messages, :message_content]
+    #   )
+    #
+    # @example With minimal configuration
+    #   client = Rubord::Client.new
+    #
+    # @return [Rubord::Client] A new client instance.
+    def initialize(prefix: "", intents: [])
+      @token = nil
+      @intents = parse_intents(intents)
+      @prefix = prefix
+
+      @rest = nil
+      @gateway = nil
+      @listeners = Hash.new { |h, k| h[k] = [] }
+
+      @user = nil
+      @start_time = Time.now.to_i
+      @commands = Rubord::CommandRegistry.new
+      
+      @channels = Rubord::Collection.new
+      @messages = Rubord::Collection.new
+      @guilds = Rubord::Collection.new
+      @users = Rubord::Collection.new
+    end
+    
+    # Returns the current WebSocket gateway latency in milliseconds.
+    #
+    # @return [Integer] Gateway latency in ms, or 0 if not connected.
+    #
+    # @example
+    #   puts "Latency: #{client.latency}ms"
+    def latency
+      @gateway&.latency || 0
+    end
+
+    # Returns the bot's uptime in seconds since login.
+    #
+    # @return [Integer] Uptime in seconds, or 0 if not logged in.
+    #
+    # @example
+    #   puts "Bot has been running for #{client.uptime} seconds"
+    def uptime
+      return 0 unless @start_time
+      Time.now.to_i - @start_time
+    end
+
+    # Retrieves the bot application's owner.
+    #
+    # This method fetches the application owner information from Discord
+    # and caches it for subsequent calls.
+    #
+    # @return [Rubord::User, nil] The application owner user object,
+    #   or nil if not logged in.
+    #
+    # @example
+    #   owner = client.owner
+    #   puts "Bot owned by: #{owner.username}"
+    def owner
+      return nil unless @user
+
+      cached = @users.get(:__owner__)
+      return cached if cached
+
+      data = @rest.get_application
+      owner = Rubord::User.new(data["owner"])
+
+      @users.set(owner.id, owner)
+      @users.set(:__owner__, owner)
+
+      owner
+    end
+
+    # Authenticates and connects to the Discord API.
+    #
+    # This method initializes the REST client, connects to the Gateway,
+    # and starts processing Discord events.
+    #
+    # @param token [String] The Discord bot token.
+    #   Format: "Bot YOUR_TOKEN_HERE" or just "YOUR_TOKEN_HERE".
+    #
+    # @return [Rubord::Client] Self for method chaining.
+    #
+    # @raise [InvalidTokenError] If the token is nil or empty.
+    #
+    # @example Basic login
+    #   client.login("Bot MTExODg0OTgxOTk0NzMxOTgwOA.G0L2QN.secret")
+    #
+    # @example With method chaining
+    #   client
+    #     .login(token)
+    #     .on(:ready) { |user| puts "Ready!" }
+    def login(token)
+      raise InvalidTokenError, "Discord token cannot be empty" if token.nil? || token.strip.empty?
+
+      @token = token
+      @rest = Rubord::REST.new(token)
+      @gateway = Rubord::Gateway.new(token, @intents)
+
+      @gateway.connect do |event, data|
+        handle_event(event, data)
+      end
+
+      @start_time = Time.now.to_i
+
+      self
+    end
+
+    # Gracefully disconnects from Discord and stops the client.
+    #
+    # This method closes the WebSocket connection and stops
+    # event processing.
+    #
+    # @return [void]
+    #
+    # @example
+    #   # Handle graceful shutdown
+    #   Signal.trap("INT") do
+    #     puts "Shutting down..."
+    #     client.stop
+    #     exit
+    #   end
+    def stop
+      @gateway&.close
+    end
+
+    def on_ready(&block)
+      on(:ready, &block)
+    end
+
+    # @yieldparam message [Rubord::Message]
+    def on_message(&block)
+      on(:message_create, &block)
+    end
+
+    # @yieldparam interaction [Rubord::Interaction]
+    def on_interaction(&block)
+      on(:interaction_create, &block)
+    end
+
+    # Registers an event listener callback.
+    #
+    # @param event [Symbol, String] The event name to listen for.
+    #   Common events: `:ready`, `:message_create`, `:guild_create`, etc.
+    # @yield [*args] The block to execute when the event fires.
+    #   Block arguments vary by event type.
+    #
+    # @return [void]
+    #
+    # @example Listening for ready event
+    #   client.on(:ready) do |user|
+    #     puts "Logged in as #{user.username}"
+    #   end
+    #
+    # @example Listening for messages
+    #   client.on(:message_create) do |message|
+    #     if message.content == "ping"
+    #       message.reply("pong")
+    #     end
+    #   end
+    #
+    # @see #trigger For event triggering mechanism
+    def on(event, &block)
+      @listeners[event.to_sym] << block
+    end
+
+    # Fetches a channel from Discord API and caches it.
+    #
+    # @param channel_id [String, Integer] The Discord channel ID to fetch.
+    #
+    # @return [Rubord::Channel] The channel object.
+    #
+    # @example
+    #   channel = client.fetch_channel("123456789012345678")
+    #   puts "Channel name: #{channel.name}"
+    def fetch_channel(channel_id)
+      data = @rest.get_channel(channel_id)
+      channel = Rubord::Channel.new(data, self)
+      @channels.set(channel.id, channel)
+      channel
+    end
+
+    # Fetches a message from Discord API and caches it.
+    #
+    # @param channel_id [String, Integer] The ID of the channel containing the message.
+    # @param message_id [String, Integer] The ID of the message to fetch.
+    #
+    # @return [Rubord::Message] The message object.
+    #
+    # @example
+    #   message = client.fetch_message("123456789012345678", "987654321098765432")
+    #   puts "Message content: #{message.content}"
+    def fetch_message(channel_id, message_id)
+      data = @rest.get_message(channel_id, message_id)
+      msg = Rubord::Message.new(data, self)
+      @messages.set(msg.id, msg)
+      msg
+    end
+
+    private
+
+  def process_command(message)
+    return if message.author.bot
+    return unless @prefix && !@prefix.empty?
+    return unless message.content.start_with?(@prefix)
+
+    input = message.content[@prefix.length..].strip
+    return if input.empty?
+
+    name, *args = input.split(/\s+/)
+    name.downcase!
+
+    command = @commands.get(name)
+    return unless command
+
+    command.run(message, args = args)
+  rescue => e
+    Rubord::Logger.warn "[Rubord:Command Error] #{e.class}: #{e.message}"
+    Rubord::Logger.warn e.backtrace.join("\n")
+  end
+
+    # Internal event handler for gateway events.
+    #
+    # This method processes raw gateway events, creates appropriate
+    # objects, updates caches, and triggers registered listeners.
+    #
+    # @param event [Symbol] The gateway event type.
+    # @param data [Hash] The event data from Discord.
+    #
+    # @return [void]
+    #
+    # @see #trigger
+    def handle_event(event, data)
+      case event
+      when :ready
+        @user = Rubord::User.new(data["user"])
+        @users.set(@user.id, @user)
+        trigger(:ready, @user)
+
+      when :guild_create
+        guild = Rubord::Guild.new(data, self)
+        @guilds.set(guild.id, guild)
+
+        if data["members"]
+          data["members"].each do |m|
+            guild.add_member(m)
+          end
+        end
+
+      when :guild_member_add
+        guild = @guilds.get(data["guild_id"])
+        guild&.add_member(data)
+
+      when :message_create
+        msg = Rubord::Message.new(data, self)
+        @messages.set(msg.id, msg)
+
+        process_command(msg)
+        trigger(:message_create, msg)
+
+      when :interaction_create
+        interaction = Rubord::Interaction.new(data, self)
+        trigger(:interaction_create, interaction)
+      else
+        trigger(event, data)
+      end
+    end
+
+    # Triggers all registered listeners for an event.
+    #
+    # @param event [Symbol] The event to trigger.
+    # @param args [Array] Arguments to pass to listeners.
+    #
+    # @return [void]
+    #
+    # @note Listeners can accept either `(client, *args)` or just `(*args)`
+    #   depending on their arity.
+    def trigger(event, payload)
+      return unless @listeners[event]
+
+      @listeners[event].each do |cb|
+        cb.call(payload)
+      end
+    end
+
+    # Parses and combines intent symbols/values into a bitwise integer.
+    #
+    # @param intents [Array<Symbol, Integer>] Array of intent symbols or values.
+    #
+    # @return [Integer] Combined bitwise intent value.
+    #
+    # @see Rubord::Intents.combine
+    def parse_intents(intents)
+      Rubord::Intents.combine(intents)
+    end
+  end
+end

data/lib/rubord/structs/gateway.rb

@@ -0,0 +1,363 @@
+require "websocket-client-simple"
+require "json"
+require "timeout"
+
+module Rubord
+  class Gateway
+    GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json"
+
+    OPCODE_DISPATCH = 0
+    OPCODE_HEARTBEAT = 1
+    OPCODE_IDENTIFY = 2
+    OPCODE_HELLO = 10
+    OPCODE_HEARTBEAT_ACK = 11
+    OPCODE_RECONNECT = 7
+    OPCODE_INVALID_SESSION = 9
+
+    
+    attr_reader :latency, :session_id, :seq
+
+    def initialize(token, intents)
+      @token = token
+      @intents = intents
+      @seq = nil
+      @session_id = nil
+      @ws = nil
+      @stopping = false
+      @connected = false
+
+      @heartbeat_interval = nil
+      @last_heartbeat_at = nil
+      @latency = 0
+      @heartbeat_thread = nil
+      @event_handlers = {}
+
+      @mutex = Mutex.new
+    end
+
+    def connect(&block)
+      @mutex.synchronize do
+        return if @connected && !@stopping
+
+        if @token.nil? || @token.strip.empty?
+          raise InvalidTokenError, "Discord token cannot be empty"
+        end
+
+        @stopping = false
+        @connected = false
+
+        begin
+          @ws = WebSocket::Client::Simple.connect(GATEWAY_URL, headers: {
+            "User-Agent" => "DiscordBot (https://github.com/kauzxx00/rubord, 1.0.0)",
+          })
+        rescue => e
+          Rubord::Logger.error "[Rubord:Gateway] Failed to connect to Discord Gateway: #{e.message}"
+          schedule_reconnect
+          return
+        end
+
+        gateway_instance = self
+
+        @ws.on(:open) do
+          gateway_instance.handle_open
+        end
+
+        @ws.on(:message) do |event|
+          gateway_instance.handle_message(event, &block)
+        end
+
+        @ws.on(:close) do |event|
+          gateway_instance.handle_close(event)
+        end
+
+        @ws.on(:error) do |e|
+          gateway_instance.handle_error(e)
+        end
+      end
+
+      sleep 1 while !@stopping
+    end
+
+    def handle_open
+      @latency = 0
+    end
+
+    def handle_message(event, &block)
+      data = event.data.to_s
+
+      if data.nil? || data.strip.empty?
+        Rubord::Logger.warn "[Rubord:Gateway] Received empty payload"
+        return
+      end
+
+      begin
+        payload = JSON.parse(data)
+      rescue JSON::ParserError => e
+        Rubord::Logger.warn "[Rubord:Gateway] Failed to parse JSON: #{e.message}"
+        Rubord::Logger.warn "[Rubord:Gateway] Raw data: #{data.inspect[0..100]}" if data && data.length > 0
+        return
+      end
+
+      op = payload["op"]
+      t = payload["t"]
+      d = payload["d"]
+      s = payload["s"]
+
+      @mutex.synchronize do
+        @seq = s if s && s > 0
+
+        case op
+        when OPCODE_HELLO
+          handle_hello(d)
+        when OPCODE_HEARTBEAT_ACK
+          handle_heartbeat_ack
+        when OPCODE_RECONNECT
+          Rubord::Logger.warn "[Rubord:Gateway] Discord requested reconnect"
+          schedule_reconnect
+        when OPCODE_INVALID_SESSION
+          handle_invalid_session(d)
+        when OPCODE_DISPATCH
+          handle_dispatch(t, d, &block)
+        else
+          Rubord::Logger.warn "[Rubord:Gateway] Unhandled opcode: #{op}"
+        end
+      end
+    rescue => e
+      Rubord::Logger.warn "[Rubord:Gateway] Error processing message: #{e.message}"
+      Rubord::Logger.warn e.backtrace.join("\n") if e.backtrace
+    end
+
+    def handle_close(event)
+      Rubord::Logger.warn "[Rubord:Gateway] WebSocket connection closed: code=#{event.code}, reason=#{event.reason}"
+      cleanup_connection
+      schedule_reconnect unless @stopping
+    end
+
+    def handle_error(e)
+      Rubord::Logger.warn "[Rubord:Gateway] WebSocket error: #{e.message}"
+      Rubord::Logger.warn e.backtrace.join("\n") if e.backtrace
+      cleanup_connection
+      schedule_reconnect unless @stopping
+    end
+
+    def handle_hello(data)
+      @heartbeat_interval = data["heartbeat_interval"].to_f / 1000.0
+      @connected = true
+
+      if @session_id && @seq
+        resume_connection
+      else
+        start_heartbeat
+        identify
+      end
+    end
+
+    def handle_heartbeat_ack
+      if @last_heartbeat_at
+        @latency = ((Time.now - @last_heartbeat_at) * 1000).round
+      end
+    end
+
+    def handle_invalid_session(resumable)
+      Rubord::Logger.warn "[Rubord:Gateway] Invalid session (resumable: #{resumable})"
+
+      if resumable && @session_id && @seq
+        Rubord::Logger.warn "[Rubord:Gateway] Attempting to resume session"
+        sleep rand(1..3)
+        identify
+      else
+        Rubord::Logger.warn "[Rubord:Gateway] Starting new session"
+        @session_id = nil
+        @seq = nil
+        sleep rand(1..5)
+        identify
+      end
+    end
+
+    def handle_dispatch(event_type, data, &block)
+      if event_type == "READY"
+        @session_id = data["session_id"]
+        @connected = true
+      end
+
+      event_map = {
+        "READY" => :ready,
+        "RESUMED" => :resumed,
+        "MESSAGE_CREATE" => :message_create,
+        "MESSAGE_UPDATE" => :message_update,
+        "MESSAGE_DELETE" => :message_delete,
+        "GUILD_CREATE" => :guild_create,
+        "GUILD_DELETE" => :guild_delete,
+        "CHANNEL_CREATE" => :channel_create,
+        "CHANNEL_DELETE" => :channel_delete,
+        "INTERACTION_CREATE" => :interaction_create,
+        "MESSAGE_REACTION_ADD" => :reaction_add,
+        "MESSAGE_REACTION_REMOVE" => :reaction_remove,
+        "TYPING_START" => :typing_start,
+        "PRESENCE_UPDATE" => :presence_update,
+      }
+
+      event_symbol = event_map[event_type]
+
+      if event_symbol && block_given?
+        begin
+          block.call(event_symbol, data)
+        rescue => e
+          Rubord::Logger.warn "[Rubord:Gateway] Error in event handler for #{event_type}: #{e.message}"
+          Rubord::Logger.warn e.full_message
+        end
+      elsif event_type && !["PRESENCE_UPDATE", "TYPING_START", "GUILD_MEMBER_UPDATE"].include?(event_type)
+        Rubord::Logger.warn "[Rubord:Gateway] Unhandled event: #{event_type}"
+      end
+    end
+
+    def identify
+      payload = {
+        op: OPCODE_IDENTIFY,
+        d: {
+          token: @token,
+          intents: @intents,
+          properties: {
+            "$os": "linux",
+            "$browser": "Rubord",
+            "$device": "Rubord",
+          },
+          compress: false,
+          large_threshold: 250,
+          shard: [0, 1],
+        },
+      }
+
+      send_payload(payload)
+    end
+
+    def resume_connection
+      Rubord::Logger.warn "[Rubord:Gateway] Attempting to resume session #{@session_id} at seq #{@seq}"
+
+      payload = {
+        op: 6,
+        d: {
+          token: @token,
+          session_id: @session_id,
+          seq: @seq,
+        },
+      }
+
+      send_payload(payload)
+    end
+
+    def start_heartbeat
+      return unless @heartbeat_interval && @heartbeat_interval > 0
+
+      @heartbeat_thread&.kill rescue nil
+
+      @heartbeat_thread = Thread.new do
+        while !@stopping && @connected
+          begin
+            sleep @heartbeat_interval
+
+            break if @stopping || !@connected
+
+            if @last_heartbeat_at && (Time.now - @last_heartbeat_at) > (@heartbeat_interval * 3)
+              Rubord::Logger.warn "[Rubord:Gateway] No heartbeat ACK received, reconnecting..."
+              schedule_reconnect
+              break
+            end
+
+            heartbeat_payload = { op: OPCODE_HEARTBEAT, d: @seq }
+            @last_heartbeat_at = Time.now
+            send_payload(heartbeat_payload)
+
+            Rubord::Logger.warn "[Rubord:Gateway] Sent heartbeat (seq: #{@seq})" if ENV["DEBUG"]
+          rescue => e
+            Rubord::Logger.warn "[Rubord:Gateway] Heartbeat error: #{e.message}"
+            schedule_reconnect
+            break
+          end
+        end
+      end
+    end
+
+    def send_payload(payload)
+      return if @stopping || !@ws
+
+      begin
+        json = payload.to_json
+        @ws.send(json)
+
+        if ENV["DEBUG"]
+          opcode_name = case payload[:op] || payload["op"]
+            when 1 then "HEARTBEAT"
+            when 2 then "IDENTIFY"
+            when 6 then "RESUME"
+            else "OP#{payload[:op] || payload["op"]}"
+            end
+          Rubord::Logger.warn "[Rubord:Gateway] Sent #{opcode_name}"
+        end
+      rescue => e
+        Rubord::Logger.warn "[Rubord:Gateway] Failed to send payload: #{e.message}"
+        schedule_reconnect
+      end
+    end
+
+    def schedule_reconnect
+      return if @stopping
+
+      Thread.new do
+        @mutex.synchronize do
+          cleanup_connection
+
+          delay = 1
+          max_delay = 30
+
+          while !@stopping
+            Rubord::Logger.warn "[Rubord:Gateway] Reconnecting in #{delay}s..."
+            sleep delay
+
+            begin
+              connect
+              break if @connected
+            rescue => e
+              Rubord::Logger.warn "[Rubord:Gateway] Reconnect failed: #{e.message}"
+            end
+
+            delay = [delay * 2, max_delay].min
+          end
+        end
+      end
+    end
+
+    def cleanup_connection
+      @connected = false
+
+      @heartbeat_thread&.kill rescue nil
+      @heartbeat_thread = nil
+
+      begin
+        @ws&.close if @ws.respond_to?(:close)
+      rescue
+      end
+      @ws = nil
+    end
+
+    def reconnect
+      Rubord::Logger.warn "[Rubord:Gateway] Manual reconnect requested"
+      schedule_reconnect
+    end
+
+    def disconnect
+      Rubord::Logger.warn "[Rubord:Gateway] Disconnecting..."
+
+      @mutex.synchronize do
+        @stopping = true
+        @connected = false
+
+        cleanup_connection
+      end
+    end
+
+    def connected?
+      @connected && !@stopping
+    end
+  end
+end