discorb 0.0.1

data/lib/discorb/client.rb

@@ -0,0 +1,363 @@
+# frozen_string_literal: true
+
+require "json"
+require "logger"
+
+require "async"
+require "async/websocket/client"
+
+module Discorb
+  #
+  # Class for connecting to the Discord server.
+  #
+  class Client
+    # @return [Discorb::Intents] The intents that the client is currently using.
+    attr_accessor :intents
+    # @return [Discorb::Application] The application that the client is using.
+    # @return [nil] If never fetched application by {#fetch_application}.
+    attr_reader :application
+    # @return [Discorb::Internet] The internet client.
+    attr_reader :internet
+    # @return [Integer] The heartbeat interval.
+    attr_reader :heartbeat_interval
+    # @return [Integer] The API version of the Discord gateway.
+    # @return [nil] If not connected to the gateway.
+    attr_reader :api_version
+    # @return [String] The token of the client.
+    attr_reader :token
+    # @return [Discorb::AllowedMentions] The allowed mentions that the client is using.
+    attr_reader :allowed_mentions
+    # @return [Discorb::ClientUser] The client user.
+    attr_reader :user
+    # @return [Discorb::Dictionary{Discorb::Snowflake => Discorb::Guild}] A dictionary of guilds.
+    attr_reader :guilds
+    # @return [Discorb::Dictionary{Discorb::Snowflake => Discorb::User}] A dictionary of users.
+    attr_reader :users
+    # @return [Discorb::Dictionary{Discorb::Snowflake => Discorb::Channel}] A dictionary of channels.
+    attr_reader :channels
+    # @return [Discorb::Dictionary{Discorb::Snowflake => Discorb::Emoji}] A dictionary of emojis.
+    attr_reader :emojis
+    # @return [Discorb::Dictionary{Discorb::Snowflake => Discorb::Message}] A dictionary of messages.
+    attr_reader :messages
+    # @return [Discorb::Logger] The logger.
+    attr_reader :log
+
+    #
+    # Initializes a new client.
+    #
+    # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions that the client is using.
+    # @param [Discorb::Intents] intents The intents that the client is currently using.
+    # @param [Integer] message_caches The number of messages to cache.
+    # @param [#puts] log The IO object to use for logging.
+    # @param [Boolean] colorize_log Whether to colorize the log.
+    # @param [:debug, :info, :warn, :error, :critical] log_level The log level.
+    # @param [Boolean] wait_until_ready Whether to delay event dispatch until ready.
+    #
+    def initialize(allowed_mentions: nil, intents: nil, message_caches: 1000, log: nil, colorize_log: false, log_level: :info, wait_until_ready: true)
+      @allowed_mentions = allowed_mentions || AllowedMentions.new(everyone: true, roles: true, users: true)
+      @intents = (intents or Intents.default)
+      @events = {}
+      @api_version = nil
+      @log = Logger.new(log, colorize_log, log_level)
+      @user = nil
+      @users = Discorb::Dictionary.new
+      @channels = Discorb::Dictionary.new
+      @guilds = Discorb::Dictionary.new(sort: ->(k) { k[0].to_i })
+      @emojis = Discorb::Dictionary.new
+      @messages = Discorb::Dictionary.new(limit: message_caches)
+      @application = nil
+      @last_s = nil
+      @identify_presence = nil
+      @wait_until_ready = wait_until_ready
+      @ready = false
+      @tasks = []
+      @conditions = {}
+    end
+
+    #
+    # Registers an event handler.
+    # @see file:docs/Events.md
+    #
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] id Custom ID of the event.
+    # @param [Hash] discriminator The discriminator of the event.
+    # @param [Proc] block The block to execute when the event is triggered.
+    #
+    # @return [Discorb::Event] The event.
+    #
+    def on(event_name, id: nil, **discriminator, &block)
+      ne = Event.new(block, id, discriminator)
+      @events[event_name] ||= []
+      @events[event_name] << ne
+      ne
+    end
+
+    #
+    # Almost same as {#on}, but only triggers the event once.
+    #
+    # @param (see #on)
+    #
+    # @return [Discorb::Event] The event.
+    #
+    def once(event_name, id: nil, **discriminator, &block)
+      discriminator[:once] = true
+      ne = Event.new(block, id, discriminator)
+      @events[event_name] ||= []
+      @events[event_name] << ne
+      ne
+    end
+
+    #
+    # Remove event by ID.
+    #
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] id The ID of the event.
+    #
+    def remove_event(event_name, id)
+      @events[event_name].delete_if { |e| e.id == id }
+    end
+
+    #
+    # Dispatch an event.
+    #
+    # @param [Symbol] event_name The name of the event.
+    # @param [Object] args The arguments to pass to the event.
+    #
+    def dispatch(event_name, *args)
+      Async do |_task|
+        if (conditions = @conditions[event_name])
+          ids = Set[*conditions.map(&:first).map(&:object_id)]
+          conditions.delete_if do |condition|
+            next unless ids.include?(condition.first.object_id)
+
+            check_result = condition[1].nil? || condition[1].call(*args)
+            if check_result
+              condition.first.signal(args)
+              true
+            else
+              false
+            end
+          end
+        end
+        if @events[event_name].nil?
+          @log.debug "Event #{event_name} doesn't have any proc, skipping"
+          next
+        end
+        @log.debug "Dispatching event #{event_name}"
+        @events[event_name].each do |block|
+          lambda { |event_args|
+            Async(annotation: "Discorb event: #{event_name}") do |task|
+              @events[event_name].delete(block) if block.discriminator[:once]
+              block.call(task, *event_args)
+              @log.debug "Dispatched proc with ID #{block.id.inspect}"
+            rescue StandardError, ScriptError => e
+              message = "An error occurred while dispatching proc with ID #{block.id.inspect}\n#{e.full_message}"
+              dispatch(:error, event_name, event_args, e)
+              if @log.out
+                @log.error message
+              else
+                warn message
+              end
+            end
+          }.call(args)
+        end
+      end
+    end
+
+    #
+    # Starts the client.
+    #
+    # @param [String] token The token to use.
+    #
+    def run(token)
+      @token = token.to_s
+      connect_gateway(true)
+    end
+
+    #
+    # Fetch user from ID.
+    # @macro async
+    # @macro http
+    #
+    # @param [#to_s] id <description>
+    #
+    # @return [Discorb::User] The user.
+    #
+    # @raise [Discorb::NotFoundError] If the user doesn't exist.
+    #
+    def fetch_user(id)
+      Async do
+        _resp, data = internet.get("/users/#{id}").wait
+        User.new(self, data)
+      end
+    end
+
+    #
+    # Fetch channel from ID.
+    # @macro async
+    # @macro http
+    #
+    # @param [#to_s] id The ID of the channel.
+    #
+    # @return [Discorb::Channel] The channel.
+    #
+    # @raise [Discorb::NotFoundError] If the channel doesn't exist.
+    #
+    def fetch_channel(id)
+      Async do
+        _resp, data = internet.get("/channels/#{id}").wait
+        Channel.make_channel(self, data)
+      end
+    end
+
+    #
+    # Fetch guild from ID.
+    # @macro async
+    # @macro http
+    #
+    # @param [#to_s] id <description>
+    #
+    # @return [Discorb::Guild] The guild.
+    #
+    # @raise [Discorb::NotFoundError] If the guild doesn't exist.
+    #
+    def fetch_guild(id)
+      Async do
+        _resp, data = internet.get("/guilds/#{id}").wait
+        Guild.new(self, data, false)
+      end
+    end
+
+    #
+    # Fetch invite from code.
+    # @macro async
+    # @macro http
+    #
+    # @param [String] code The code of the invite.
+    # @param [Boolean] with_count Whether to include the count of the invite.
+    # @param [Boolean] with_expiration Whether to include the expiration of the invite.
+    #
+    # @return [Discorb::Invite] The invite.
+    #
+    def fetch_invite(code, with_count: false, with_expiration: false)
+      Async do
+        _resp, data = internet.get("/invites/#{code}?with_count=#{with_count}&with_expiration=#{with_expiration}").wait
+        Invite.new(self, data, false)
+      end
+    end
+
+    #
+    # Fetch webhook from ID.
+    # If application was cached, it will be used.
+    # @macro async
+    # @macro http
+    #
+    # @param [Boolean] force Whether to force the fetch.
+    #
+    # @return [Discorb::Application] The application.
+    #
+    def fetch_application(force: false)
+      Async do
+        next @application if @application && !force
+
+        _resp, data = internet.get("/oauth2/applications/@me").wait
+        @application = Application.new(self, data)
+        @application
+      end
+    end
+
+    #
+    # Fetch nitro sticker pack from ID.
+    # @macro async
+    # @macro http
+    #
+    # @return [Array<Discorb::Sticker::Pack>] The packs.
+    #
+    def fetch_nitro_sticker_packs
+      Async do
+        _resp, data = internet.get("/stickers-packs").wait
+        data.map { |pack| Sticker::Pack.new(self, pack) }
+      end
+    end
+
+    #
+    # Update presence of the client.
+    #
+    # @param [Discorb::Activity] activity The activity to update.
+    # @param [:online, :idle, :dnd, :invisible] status The status to update.
+    #
+    def update_presence(activity = nil, status: nil)
+      payload = {}
+      if !activity.nil?
+        payload[:activities] = [activity.to_hash]
+      end
+      payload[:status] = status unless status.nil?
+      if @connection
+        Async do |_task|
+          send_gateway(3, **payload)
+        end
+      else
+        @identify_presence = payload
+      end
+    end
+
+    alias change_presence update_presence
+
+    #
+    # Method to wait for a event.
+    #
+    # @param [Symbol] event_name The name of the event.
+    # @param [Integer] timeout The timeout in seconds.
+    # @param [Proc] check The check to use.
+    #
+    # @return [Object] The result of the event.
+    #
+    # @raise [Discorb::TimeoutError] If the event didn't occur in time.
+    #
+    def event_lock(event, timeout = nil, &check)
+      Async do |task|
+        condition = Async::Condition.new
+        @conditions[event] ||= []
+        @conditions[event] << [condition, check]
+        if timeout.nil?
+          value = condition.wait
+        else
+          timeout_task = task.with_timeout(timeout) do
+            condition.wait
+          rescue Async::TimeoutError
+            @conditions[event].delete_if { |c| c.first == condition }
+            raise Discorb::TimeoutError, "Timeout waiting for event #{event}", cause: nil
+          end
+          value = timeout_task
+        end
+        value.length <= 1 ? value.first : value
+      end
+    end
+
+    alias await event_lock
+
+    def inspect
+      "#<#{self.class} user=\"#{user}\">"
+    end
+
+    #
+    # Load the extension.
+    #
+    # @param [Module] mod The extension to load.
+    #
+    def extend(mod)
+      if mod.respond_to?(:events)
+        mod.events.each do |name, events|
+          @events[name] = [] if @events[name].nil?
+          events.each do |event|
+            @events[name] << event
+          end
+        end
+        mod.client = self
+      end
+      super(mod)
+    end
+
+    include Discorb::GatewayHandler
+  end
+end

data/lib/discorb/color.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents RGB color.
+  #
+  class Color
+    attr_accessor :value
+
+    @discord_colors = {
+      teal: 0x1abc9c,
+      dark_teal: 0x11806a,
+      green: 0x2ecc71,
+      dark_green: 0x1f8b4c,
+      blue: 0x3498db,
+      dark_blue: 0x206694,
+      purple: 0x9b59b6,
+      dark_purple: 0x71368a,
+      magenta: 0xe91e63,
+      dark_magenta: 0xad1457,
+      gold: 0xf1c40f,
+      dark_gold: 0xc27c0e,
+      orange: 0xe67e22,
+      dark_orange: 0xa84300,
+      red: 0xe74c3c,
+      dark_red: 0x992d22,
+      lighter_grey: 0x95a5a6,
+      lighter_gray: 0x95a5a6,
+      dark_grey: 0x607d8b,
+      dark_gray: 0x607d8b,
+      light_grey: 0x979c9f,
+      light_gray: 0x979c9f,
+      darker_grey: 0x546e7a,
+      darker_gray: 0x546e7a,
+      og_blurple: 0x7289da,
+      blurple: 0x5865f2,
+      greyple: 0x99aab5,
+      dark_theme: 0x36393f,
+      fuchsia: 0xeb459e,
+      yellow: 0xfee75c,
+    }.freeze
+
+    #
+    # Create a color from a Integer.
+    #
+    # @param [Integer] value A color value.
+    #
+    def initialize(value)
+      @value = value
+    end
+
+    #
+    # Integerize a color.
+    #
+    # @return [Integer] A color value.
+    #
+    def to_i
+      @value
+    end
+
+    #
+    # Convert a color to a hexadecimal value.
+    #
+    # @return [String] A hexadecimal value.
+    #
+    def to_hex
+      @value.to_s(16).rjust(6, "0")
+    end
+
+    #
+    # Convert a color to RGB array.
+    #
+    # @return [Array(Integer, Integer, Integer)] A RGB array.
+    #
+    def to_rgb
+      [@value / (256 * 256), @value / 256 % 256, @value % 256]
+    end
+
+    alias to_a to_rgb
+    alias deconstruct to_rgb
+
+    #
+    # Convert a color to RGB hash.
+    #
+    # @return [Hash{:r, :g, :b => Integer}] A RGB hash.
+    #
+    def to_rgb_hash
+      [@value / (256 * 256), @value / 256 % 256, @value % 256]
+    end
+
+    alias deconstruct_keys to_rgb_hash
+
+    #
+    # Converts a color to a `#000000` string.
+    #
+    # @return [String] Converted string.
+    #
+    def to_s
+      "##{to_hex}"
+    end
+
+    def inspect
+      "#<#{self.class} #{@value}/#{self}>"
+    end
+
+    #
+    # Create a color from a hexadecimal string.
+    #
+    # @param [String] hex A hexadecimal string.
+    #
+    # @return [Discorb::Color] A color object.
+    #
+    def self.from_hex(hex)
+      new(hex.to_i(16))
+    end
+
+    #
+    # Create a color from a RGB array.
+    #
+    # @param [Integer] red A red value.
+    # @param [Integer] green A green value.
+    # @param [Integer] blue A blue value.
+    #
+    # @return [Discorb::Color] A color object.
+    #
+    def self.from_rgb(red, green, blue)
+      new(red * 256 * 256 + green * 256 + blue)
+    end
+
+    #
+    # Create a color from a Discord's color.
+    # Currently these colors are supported:
+    #   - teal (0x1abc9c)
+    #   - dark_teal (0x11806a)
+    #   - green (0x2ecc71)
+    #   - dark_green (0x1f8b4c)
+    #   - blue (0x3498db)
+    #   - dark_blue (0x206694)
+    #   - purple (0x9b59b6)
+    #   - dark_purple (0x71368a)
+    #   - magenta (0xe91e63)
+    #   - dark_magenta (0xad1457)
+    #   - gold (0xf1c40f)
+    #   - dark_gold (0xc27c0e)
+    #   - orange (0xe67e22)
+    #   - dark_orange (0xa84300)
+    #   - red (0xe74c3c)
+    #   - dark_red (0x992d22)
+    #   - lighter_grey (0x95a5a6)
+    #   - lighter_gray (0x95a5a6)
+    #   - dark_grey (0x607d8b)
+    #   - dark_gray (0x607d8b)
+    #   - light_grey (0x979c9f)
+    #   - light_gray (0x979c9f)
+    #   - darker_grey (0x546e7a)
+    #   - darker_gray (0x546e7a)
+    #   - og_blurple (0x7289da)
+    #   - blurple (0x5865f2)
+    #   - greyple (0x99aab5)
+    #   - dark_theme (0x36393f)
+    #   - fuchsia (0xeb459e)
+    #
+    # @param [Symbol] color A Discord color name.
+    #
+    # @return [Discorb::Color] A color object.
+    #
+    def self.[](color)
+      new(@discord_colors[color])
+    end
+  end
+
+  Colour = Color
+end