onyxcord 1.1.0

data/lib/onyxcord/voice/voice_bot.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+require 'onyxcord/voice/encoder'
+require 'onyxcord/voice/network'
+require 'onyxcord/voice/timer'
+require 'onyxcord/logger'
+require 'ffi'
+
+# Voice support
+module OnyxCord::Voice
+  # How long one voice packet should ideally be (20ms as defined by Discord)
+  IDEAL_LENGTH = 20.0
+
+  # How many bytes of data to read (1920 bytes * 2 channels) from audio PCM data
+  DATA_LENGTH = 1920 * 2
+
+  # This class represents a connection to a Discord voice server and channel. It can be used to play audio files and
+  # streams and to control playback on currently playing tracks. The method {Bot#voice_connect} can be used to connect
+  # to a voice channel.
+  #
+  # onyxcord does latency adjustments every now and then to improve playback quality. I made sure to put useful
+  # defaults for the adjustment parameters, but if the sound is patchy or too fast (or the speed varies a lot) you
+  # should check the parameters and adjust them to your connection: {VoiceBot#adjust_interval},
+  # {VoiceBot#adjust_offset}, and {VoiceBot#adjust_average}.
+  class VoiceBot
+    # @return [Channel] the current voice channel
+    attr_reader :channel
+
+    # @!visibility private
+    attr_writer :channel
+
+    # @return [Integer, nil] the amount of time the stream has been playing, or `nil` if nothing has been played yet.
+    attr_reader :stream_time
+
+    # @return [Encoder] the encoder used to encode audio files into the format required by Discord.
+    attr_reader :encoder
+
+    # onyxcord will occasionally measure the time it takes to send a packet, and adjust future delay times based
+    # on that data. This makes voice playback more smooth, because if packets are sent too slowly, the audio will
+    # sound patchy, and if they're sent too quickly, packets will "pile up" and occasionally skip some data or
+    # play parts back too fast. How often these measurements should be done depends a lot on the system, and if it's
+    # done too quickly, especially on slow connections, the playback speed will vary wildly; if it's done too slowly
+    # however, small errors will cause quality problems for a longer time.
+    # @return [Integer] how frequently audio length adjustments should be done, in ideal packets (20ms).
+    attr_accessor :adjust_interval
+
+    # This particular value is also important because ffmpeg may take longer to process the first few packets. It is
+    # recommended to set this to 10 at maximum, otherwise it will take too long to make the first adjustment, but it
+    # shouldn't be any higher than {#adjust_interval}, otherwise no adjustments will take place. If {#adjust_interval}
+    # is at a value higher than 10, this value should not be changed at all.
+    # @see #adjust_interval
+    # @return [Integer] the packet number (1 packet = 20ms) at which length adjustments should start.
+    attr_accessor :adjust_offset
+
+    # This value determines whether or not the adjustment length should be averaged with the previous value. This may
+    # be useful on slower connections where latencies vary a lot. In general, it will make adjustments more smooth,
+    # but whether that is desired behaviour should be tried on a case-by-case basis.
+    # @see #adjust_interval
+    # @return [true, false] whether adjustment lengths should be averaged with the respective previous value.
+    attr_accessor :adjust_average
+
+    # Disable the debug message for length adjustment specifically, as it can get quite spammy with very low intervals
+    # @see #adjust_interval
+    # @return [true, false] whether length adjustment debug messages should be printed
+    attr_accessor :adjust_debug
+
+    # If this value is set, no length adjustments will ever be done and this value will always be used as the length
+    # (i.e. packets will be sent every N seconds). Be careful not to set it too low as to not spam Discord's servers.
+    # The ideal length is 20ms (accessible by the {OnyxCord::Voice::IDEAL_LENGTH} constant), this value should be
+    # slightly lower than that because encoding + sending takes time. Note that sending DCA files is significantly
+    # faster than sending regular audio files (usually about four times as fast), so you might want to set this value
+    # to something else if you're sending a DCA file.
+    # @return [Float] the packet length that should be used instead of calculating it during the adjustments, in ms.
+    attr_accessor :length_override
+
+    # The factor the audio's volume should be multiplied with. `1` is no change in volume, `0` is completely silent,
+    # `0.5` is half the default volume and `2` is twice the default.
+    # @return [Float] the volume for audio playback, `1.0` by default.
+    attr_accessor :volume
+
+    # @!visibility private
+    def initialize(channel, bot, token, session, endpoint)
+      @bot = bot
+      @channel = channel
+
+      @ws = VoiceWS.new(channel, bot, token, session, endpoint)
+      @udp = @ws.udp
+
+      @sequence = @time = 0
+      @skips = 0
+
+      @adjust_interval = 100
+      @adjust_offset = 10
+      @adjust_average = false
+      @adjust_debug = true
+
+      @volume = 1.0
+      @playing = false
+
+      @encoder = Encoder.new
+      @ws.connect
+    rescue StandardError => e
+      OnyxCord::LOGGER.log_exception(e)
+      raise
+    end
+
+    # @return [true, false] whether audio data sent will be encrypted.
+    # @deprecated Discord no longer supports unencrypted voice communication.
+    def encrypted?
+      true
+    end
+
+    # Set the filter volume. This volume is applied as a filter for decoded audio data. It has the advantage that using
+    # it is much faster than regular volume, but it can only be changed before starting to play something.
+    # @param value [Integer] The value to set the volume to. For possible values, see {#volume}
+    def filter_volume=(value)
+      @encoder.filter_volume = value
+    end
+
+    # @see #filter_volume=
+    # @return [Integer] the volume used as a filter for ffmpeg/avconv.
+    def filter_volume
+      @encoder.filter_volume
+    end
+
+    # Pause playback. This is not instant; it may take up to 20 ms for this change to take effect. (This is usually
+    # negligible.)
+    def pause
+      @paused = true
+    end
+
+    # @see #play
+    # @return [true, false] Whether it is playing sound or not.
+    def playing?
+      @playing
+    end
+
+    alias_method :isplaying?, :playing?
+
+    # Continue playback. This change may take up to 100ms to take effect, which is usually negligible.
+    def continue
+      @paused = false
+    end
+
+    # Skips to a later time in the song. It's impossible to go back without replaying the song.
+    # @param secs [Float] How many seconds to skip forwards. Skipping will always be done in discrete intervals of
+    #   0.05 seconds, so if the given amount is smaller than that, it will be rounded up.
+    def skip(secs)
+      @skips += (secs * (1000 / IDEAL_LENGTH)).ceil
+    end
+
+    # Sets whether or not the bot is speaking (green circle around user).
+    # @param value [true, false, Integer] whether or not the bot should be speaking, or a bitmask denoting the audio type
+    # @note https://discord.com/developers/docs/topics/voice-connections#speaking for information on the speaking bitmask
+    def speaking=(value)
+      @playing = value
+      @ws.send_speaking(value)
+    end
+
+    # Stops the current playback entirely.
+    # @param wait_for_confirmation [true, false] Whether the method should wait for confirmation from the playback
+    #   method that the playback has actually stopped.
+    def stop_playing(wait_for_confirmation = false)
+      @was_playing_before = @playing
+      @speaking = false
+      @playing = false
+      sleep IDEAL_LENGTH / 1000.0 if @was_playing_before
+
+      return unless wait_for_confirmation
+
+      @has_stopped_playing = false
+      sleep IDEAL_LENGTH / 1000.0 until @has_stopped_playing
+      @has_stopped_playing = false
+    end
+
+    # Permanently disconnects from the voice channel; to reconnect you will have to call {Bot#voice_connect} again.
+    def destroy
+      stop_playing
+      @bot.voice_destroy(@channel.server.id, false)
+      @ws.destroy
+    end
+
+    # Plays a stream of raw data to the channel. All playback methods are blocking, i.e. they wait for the playback to
+    # finish before exiting the method. This doesn't cause a problem if you just use onyxcord events/commands to
+    # play stuff, as these are fully threaded, but if you don't want this behaviour anyway, be sure to call these
+    # methods in separate threads.
+    # @param encoded_io [IO] A stream of raw PCM data (s16le)
+    def play(encoded_io)
+      stop_playing(true) if @playing
+      @retry_attempts = 3
+      @first_packet = true
+
+      play_internal do
+        buf = nil
+
+        # Read some data from the buffer
+        begin
+          buf = encoded_io.readpartial(DATA_LENGTH) if encoded_io
+        rescue EOFError
+          raise IOError, 'File or stream not found!' if @first_packet
+
+          @bot.debug('EOF while reading, breaking immediately')
+          next :stop
+        end
+
+        # Check whether the buffer has enough data
+        if !buf || buf.length != DATA_LENGTH
+          @bot.debug("No data is available! Retrying #{@retry_attempts} more times")
+          next :stop if @retry_attempts.zero?
+
+          @retry_attempts -= 1
+          next
+        end
+
+        # Adjust volume
+        buf = @encoder.adjust_volume(buf, @volume) if @volume != 1.0 # rubocop:disable Lint/FloatComparison
+
+        @first_packet = false
+
+        # Encode data
+        @encoder.encode(buf)
+      end
+
+      # If the stream is a process, kill it
+      if encoded_io&.pid
+        OnyxCord::LOGGER.debug("Killing ffmpeg process with pid #{encoded_io.pid.inspect}")
+
+        begin
+          pid = encoded_io.pid
+          # Windows does not support TERM as a kill signal, so we use KILL. `Process.waitpid` verifies that our
+          # child process has not already completed.
+          Process.kill(Gem.win_platform? ? 'KILL' : 'TERM', pid) if Process.waitpid(pid, Process::WNOHANG).nil?
+        rescue StandardError => e
+          OnyxCord::LOGGER.warn('Failed to kill ffmpeg process! You *might* have a process leak now.')
+          OnyxCord::LOGGER.warn("Reason: #{e}")
+        end
+      end
+
+      # Close the stream
+      encoded_io.close
+    end
+
+    # Plays an encoded audio file of arbitrary format to the channel.
+    # @see Encoder#encode_file
+    # @see #play
+    def play_file(file, options = '')
+      play @encoder.encode_file(file, options)
+    end
+
+    # Plays a stream of encoded audio data of arbitrary format to the channel.
+    # @see Encoder#encode_io
+    # @see #play
+    def play_io(io, options = '')
+      play @encoder.encode_io(io, options)
+    end
+
+    # Plays a stream of audio data in the DCA format. This format has the advantage that no recoding has to be
+    # done - the file contains the data exactly as Discord needs it.
+    # @note DCA playback will not be affected by the volume modifier ({#volume}) because the modifier operates on raw
+    #   PCM, not opus data. Modifying the volume of DCA data would involve decoding it, multiplying the samples and
+    #   re-encoding it, which defeats its entire purpose (no recoding).
+    # @see https://github.com/bwmarrin/dca
+    # @see #play
+    def play_dca(file)
+      stop_playing(true) if @playing
+
+      @bot.debug "Reading DCA file #{file}"
+      input_stream = File.open(file)
+
+      magic = input_stream.read(4)
+      raise ArgumentError, 'Not a DCA1 file! The file might have been corrupted, please recreate it.' unless magic == 'DCA1'
+
+      # Read the metadata header, then read the metadata and discard it as we don't care about it
+      metadata_header = input_stream.read(4).unpack1('l<')
+      input_stream.read(metadata_header)
+
+      # Play the data, without re-encoding it to opus
+      play_internal do
+        begin
+          # Read header
+          header_str = input_stream.read(2)
+
+          unless header_str
+            @bot.debug 'Finished DCA parsing (header is nil)'
+            next :stop
+          end
+
+          header = header_str.unpack1('s<')
+
+          raise 'Negative header in DCA file! Your file is likely corrupted.' if header.negative?
+        rescue EOFError
+          @bot.debug 'Finished DCA parsing (EOFError)'
+          next :stop
+        end
+
+        # Read bytes
+        input_stream.read(header)
+      end
+    end
+
+    alias_method :play_stream, :play_io
+
+    private
+
+    # Plays the data from the IO stream as Discord requires it
+    def play_internal
+      count = 0
+      @playing = true
+      self.speaking = true
+
+      last_sent = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+      loop do
+        # If paused, wait
+        sleep 0.1 while @paused
+
+        break unless @playing
+
+        # Get timestamp before encoding
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+        # If we should skip, get some data, discard it and go to the next iteration
+        if @skips.positive?
+          @skips -= 1
+          yield
+          next
+        end
+
+        # Track packet count, sequence and time (Discord requires this)
+        count += 1
+        increment_packet_headers
+
+        # Get packet data
+        buf = yield
+
+        # Stop doing anything if the stop signal was sent
+        break if buf == :stop
+
+        # Proceed to the next packet if we got nil
+        next unless buf
+
+        # Track intermediate adjustment so we can measure how much encoding contributes to the total time
+        intermediate_adjust = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+        Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+        if (last_sent + IDEAL_LENGTH) > Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+          sleep_duration = (last_sent + IDEAL_LENGTH - Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)) / 1000.0
+          @bot.debug("Waiting for next frame: #{sleep_duration * 1000}ms (encoding #{intermediate_adjust - start_time}ms)") if @adjust_debug
+          sleep sleep_duration if sleep_duration.positive?
+        end
+
+        # Send the packet
+        @udp.send_audio(buf, @sequence, @time)
+
+        # Set the stream time (for tracking how long we've been playing)
+        @stream_time = count * IDEAL_LENGTH / 1000
+        last_sent = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+      end
+
+      @bot.debug('Sending five silent frames to clear out buffers')
+
+      5.times do
+        increment_packet_headers
+        @udp.send_audio(Encoder::OPUS_SILENCE, @sequence, @time)
+
+        # Length adjustments don't matter here, we can just wait 20ms since nobody is going to hear it anyway
+        sleep IDEAL_LENGTH / 1000.0
+      end
+
+      @bot.debug('Performing final cleanup after stream ended')
+
+      # Final clean-up
+      stop_playing
+
+      # Notify any stop_playing methods running right now that we have actually stopped
+      @has_stopped_playing = true
+    end
+
+    # Increment sequence and time
+    def increment_packet_headers
+      @sequence + 10 < 65_535 ? @sequence += 1 : @sequence = 0
+      @time + 9600 < 4_294_967_295 ? @time += 960 : @time = 0
+    end
+  end
+end

data/lib/onyxcord/webhooks.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'onyxcord/webhooks/version'
+require 'onyxcord/webhooks/embeds'
+require 'onyxcord/webhooks/client'
+require 'onyxcord/webhooks/builder'
+require 'onyxcord/webhooks/view'
+require 'onyxcord/webhooks/modal'
+
+module OnyxCord
+  # Webhook client
+  module Webhooks
+  end
+end

data/lib/onyxcord/websocket.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'websocket-client-simple'
+
+module OnyxCord
+  # Utility wrapper class that abstracts an instance of WSCS. Useful should we decide that WSCS isn't good either -
+  # in that case we can just switch to something else
+  class WebSocket
+    attr_reader :open_handler, :message_handler, :close_handler, :error_handler
+
+    # Create a new WebSocket and connect to the given endpoint.
+    # @param endpoint [String] Where to connect to.
+    # @param open_handler [#call] The handler that should be called when the websocket has opened successfully.
+    # @param message_handler [#call] The handler that should be called when the websocket receives a message. The
+    #   handler can take one parameter which will have a `data` attribute for normal messages and `code` and `data` for
+    #   close frames.
+    # @param close_handler [#call] The handler that should be called when the websocket is closed due to an internal
+    #   error. The error will be passed as the first parameter to the handler.
+    # @param error_handler [#call] The handler that should be called when an error occurs in another handler. The error
+    #   will be passed as the first parameter to the handler.
+    def initialize(endpoint, open_handler, message_handler, close_handler, error_handler)
+      OnyxCord::LOGGER.debug "Using WSCS version: #{::WebSocket::Client::Simple::VERSION}"
+
+      @open_handler = open_handler
+      @message_handler = message_handler
+      @close_handler = close_handler
+      @error_handler = error_handler
+
+      instance = self # to work around WSCS's weird way of handling blocks
+
+      @client = ::WebSocket::Client::Simple.connect(endpoint) do |ws|
+        ws.on(:open) { instance.open_handler.call }
+        ws.on(:message) do |msg|
+          # If the message has a code attribute, it is in reality a close message
+          if msg.code
+            instance.close_handler.call(msg)
+          else
+            instance.message_handler.call(msg.data)
+          end
+        end
+        ws.on(:close) { |err| instance.close_handler.call(err) }
+        ws.on(:error) { |err| instance.error_handler.call(err) }
+      end
+    end
+
+    # Send data over this WebSocket
+    # @param data [String] What to send
+    def send(data)
+      @client.send(data)
+    end
+
+    # Close the WebSocket connection
+    def close
+      @client.close
+    end
+
+    # @return [Thread] the internal WSCS thread
+    def thread
+      @client.thread
+    end
+  end
+end

data/lib/onyxcord.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'onyxcord/version'
+require 'onyxcord/configuration'
+require 'onyxcord/event_executor'
+require 'onyxcord/message_components'
+require 'onyxcord/bot'
+require 'onyxcord/commands/command_bot'
+require 'onyxcord/logger'
+
+# All onyxcord functionality, to be extended by other files
+module OnyxCord
+  Thread.current[:onyxcord_name] = 'main'
+
+  # The default debug logger used by onyxcord.
+  LOGGER = Logger.new(ENV.fetch('ONYXCORD_FANCY_LOG', false))
+
+  # The Unix timestamp Discord IDs are based on
+  DISCORD_EPOCH = 1_420_070_400_000
+
+  # Used to declare what events you wish to recieve from Discord.
+  # @see https://discord.com/developers/docs/topics/gateway#gateway-intents
+  INTENTS = {
+    servers: 1 << 0,
+    server_members: 1 << 1,
+    server_bans: 1 << 2,
+    server_emojis: 1 << 3,
+    server_integrations: 1 << 4,
+    server_webhooks: 1 << 5,
+    server_invites: 1 << 6,
+    server_voice_states: 1 << 7,
+    server_presences: 1 << 8,
+    server_messages: 1 << 9,
+    server_message_reactions: 1 << 10,
+    server_message_typing: 1 << 11,
+    direct_messages: 1 << 12,
+    direct_message_reactions: 1 << 13,
+    direct_message_typing: 1 << 14,
+    message_content: 1 << 15,
+    server_scheduled_events: 1 << 16,
+    server_message_polls: 1 << 24,
+    direct_message_polls: 1 << 25
+  }.freeze
+
+  INTENT_ALIASES = {
+    guilds: :servers,
+    guild_members: :server_members,
+    guild_bans: :server_bans,
+    guild_emojis: :server_emojis,
+    guild_integrations: :server_integrations,
+    guild_webhooks: :server_webhooks,
+    guild_invites: :server_invites,
+    guild_voice_states: :server_voice_states,
+    guild_presences: :server_presences,
+    guild_messages: :server_messages,
+    guild_message_reactions: :server_message_reactions,
+    guild_message_typing: :server_message_typing,
+    guild_scheduled_events: :server_scheduled_events,
+    guild_message_polls: :server_message_polls
+  }.freeze
+
+  MINIMAL_INTENTS = INTENTS.values_at(:servers, :server_messages, :direct_messages).reduce(&:|)
+
+  # All available intents
+  ALL_INTENTS = INTENTS.values.reduce(&:|)
+
+  # All unprivileged intents
+  # @see https://discord.com/developers/docs/topics/gateway#privileged-intents
+  UNPRIVILEGED_INTENTS = ALL_INTENTS & ~(INTENTS[:server_members] | INTENTS[:server_presences] | INTENTS[:message_content])
+
+  # No intents
+  NO_INTENTS = 0
+
+  # Compares two objects based on IDs - either the objects' IDs are equal, or one object is equal to the other's ID.
+  def self.id_compare?(one_id, other)
+    other.respond_to?(:resolve_id) ? (one_id.resolve_id == other.resolve_id) : (one_id == other)
+  end
+
+  # @deprecated Please use {OnyxCord.id_compare?}
+  singleton_class.alias_method :id_compare, :id_compare?
+
+  # The maximum length a Discord message can have
+  CHARACTER_LIMIT = 2000
+
+  # For creating timestamps with {timestamp}
+  # @see https://discord.com/developers/docs/reference#message-formatting-timestamp-styles
+  TIMESTAMP_STYLES = {
+    short_time: 't', # 16:20
+    long_time: 'T', # 16:20:30
+    short_date: 'd', # 20/04/2021
+    long_date: 'D', # 20 April 2021
+    short_datetime: 'f', # 20 April 2021 16:20
+    long_datetime: 'F', # Tuesday, 20 April 2021 16:20
+    relative: 'R', # 2 months ago
+    simple_datetime: 's', # 20/04/2021, 16:20
+    medium_datetime: 'S' # 20/04/2021, 16:20:30
+  }.freeze
+
+  # Splits a message into chunks of 2000 characters. Attempts to split by lines if possible.
+  # @param msg [String] The message to split.
+  # @return [Array<String>] the message split into chunks
+  def self.split_message(msg)
+    # If the messages is empty, return an empty array
+    return [] if msg.empty?
+
+    # Split the message into lines
+    lines = msg.lines
+
+    # Turn the message into a "triangle" of consecutively longer slices, for example the array [1,2,3,4] would become
+    # [
+    #  [1],
+    #  [1, 2],
+    #  [1, 2, 3],
+    #  [1, 2, 3, 4]
+    # ]
+    tri = (0...lines.length).map { |i| lines.combination(i + 1).first }
+
+    # Join the individual elements together to get an array of strings with consecutively more lines
+    joined = tri.map(&:join)
+
+    # Find the largest element that is still below the character limit, or if none such element exists return the first
+    ideal = joined.max_by { |e| e.length > CHARACTER_LIMIT ? -1 : e.length }
+
+    # If it's still larger than the character limit (none was smaller than it) split it into the largest chunk without
+    # cutting words apart, breaking on the nearest space within character limit, otherwise just return an array with one element
+    ideal_ary = ideal.length > CHARACTER_LIMIT ? ideal.split(/(.{1,#{CHARACTER_LIMIT}}\b|.{1,#{CHARACTER_LIMIT}})/o).reject(&:empty?) : [ideal]
+
+    # Slice off the ideal part and strip newlines
+    rest = msg[ideal.length..].strip
+
+    # If none remains, return an empty array -> we're done
+    return [] unless rest
+
+    # Otherwise, call the method recursively to split the rest of the string and add it onto the ideal array
+    ideal_ary + split_message(rest)
+  end
+
+  # @param time [Time, Integer] The time to create the timestamp from, or a unix timestamp integer.
+  # @param style [Symbol, String] One of the keys from {TIMESTAMP_STYLES} or a string with the style.
+  # @return [String]
+  # @example
+  #   OnyxCord.timestamp(Time.now, :short_time)
+  #   # => "<t:1632146954:t>"
+  def self.timestamp(time, style = nil)
+    if style.nil?
+      "<t:#{time.to_i}>"
+    else
+      "<t:#{time.to_i}:#{TIMESTAMP_STYLES[style] || style}>"
+    end
+  end
+
+  # A utility method to base64 encode a file like object using its mime type.
+  # @param file [File, #read] A file like object that responds to #read.
+  # @return [String] The file object encoded as base64 image data.
+  def self.encode64(file)
+    path_method = %i[original_filename path local_path].find { |method| file.respond_to?(method) }
+
+    raise ArgumentError, 'File object must respond to original_filename, path, or local path.' unless path_method
+    raise ArgumentError, 'File object must respond to read.' unless file.respond_to?(:read)
+
+    mime_type = MIME::Types.type_for(file.__send__(path_method)).first&.to_s || 'image/jpeg'
+    "data:#{mime_type};base64,#{Base64.encode64(file.read).strip}"
+  end
+end
+
+# In onyxcord, Integer and {String} are monkey-patched to allow for easy resolution of IDs
+class Integer
+  # @return [Integer] The Discord ID represented by this integer, i.e. the integer itself
+  def resolve_id
+    self
+  end
+end
+
+# In onyxcord, {Integer} and String are monkey-patched to allow for easy resolution of IDs
+class String
+  # @return [Integer] The Discord ID represented by this string, i.e. the string converted to an integer
+  def resolve_id
+    to_i
+  end
+end

data/onyxcord-webhooks.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/onyxcord/webhooks/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'onyxcord-webhooks'
+  spec.version       = OnyxCord::Webhooks::VERSION
+  spec.authors       = ['Gustavo Silva']
+  spec.email         = ['gustavosilva8kt@gmail.com']
+
+  spec.summary       = 'Webhook client for onyxcord'
+  spec.description   = "A webhook client for OnyxCord, a Ruby Discord library based on discordrb and updated with Components V2 support."
+  spec.homepage      = 'https://github.com/kruldevb/OnyxCord'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z lib/onyxcord/webhooks/`.split("\x0") + ['lib/onyxcord/webhooks.rb']
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'rest-client', '>= 2.0.0'
+
+  spec.required_ruby_version = '>= 3.3'
+  spec.metadata = {
+    'bug_tracker_uri' => 'https://github.com/kruldevb/OnyxCord/issues',
+    'documentation_uri' => 'https://github.com/kruldevb/OnyxCord#readme',
+    'source_code_uri' => 'https://github.com/kruldevb/OnyxCord',
+    'rubygems_mfa_required' => 'true'
+  }
+end