onyxcord 1.1.0

data/lib/onyxcord/permissions.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  # List of permissions Discord uses
+  class Permissions
+    # This hash maps bit positions to logical permissions.
+    FLAGS = {
+      # Bit => Permission # Value
+      0 => :create_instant_invite,        # 1
+      1 => :kick_members,                 # 2
+      2 => :ban_members,                  # 4
+      3 => :administrator,                # 8
+      4 => :manage_channels,              # 16
+      5 => :manage_server,                # 32
+      6 => :add_reactions,                # 64
+      7 => :view_audit_log,               # 128
+      8 => :priority_speaker,             # 256
+      9 => :stream,                       # 512
+      10 => :read_messages,               # 1024
+      11 => :send_messages,               # 2048
+      12 => :send_tts_messages,           # 4096
+      13 => :manage_messages,             # 8192
+      14 => :embed_links,                 # 16384
+      15 => :attach_files,                # 32768
+      16 => :read_message_history,        # 65536
+      17 => :mention_everyone,            # 131072
+      18 => :use_external_emoji,          # 262144
+      19 => :view_server_insights,        # 524288
+      20 => :connect,                     # 1048576
+      21 => :speak,                       # 2097152
+      22 => :mute_members,                # 4194304
+      23 => :deafen_members,              # 8388608
+      24 => :move_members,                # 16777216
+      25 => :use_voice_activity,          # 33554432
+      26 => :change_nickname,             # 67108864
+      27 => :manage_nicknames,            # 134217728
+      28 => :manage_roles,                # 268435456, also Manage Permissions
+      29 => :manage_webhooks,             # 536870912
+      30 => :manage_emojis,               # 1073741824, also Manage Stickers
+      31 => :use_slash_commands,          # 2147483648
+      32 => :request_to_speak,            # 4294967296
+      33 => :manage_events,               # 8589934592
+      34 => :manage_threads,              # 17179869184
+      35 => :use_public_threads,          # 34359738368
+      36 => :use_private_threads,         # 68719476736
+      37 => :use_external_stickers,       # 137438953472
+      38 => :send_messages_in_threads,    # 274877906944
+      39 => :use_embedded_activities,     # 549755813888
+      40 => :moderate_members,            # 1099511627776
+      41 => :view_monetization_analytics, # 2199023255552
+      42 => :use_soundboard,              # 4398046511104
+      43 => :create_server_expressions,   # 8796093022208
+      44 => :create_scheduled_events,     # 17592186044416
+      45 => :use_external_sounds,         # 35184372088832
+      46 => :send_voice_messages,         # 70368744177664
+      49 => :send_polls,                  # 562949953421312
+      50 => :use_external_apps,           # 1125899906842624
+      51 => :pin_messages,                # 2251799813685248
+      52 => :bypass_slowmode              # 4503599627370496
+    }.freeze
+
+    FLAGS.each do |position, flag|
+      attr_reader flag
+
+      define_method "can_#{flag}=" do |value|
+        new_bits = @bits
+        if value
+          new_bits |= (1 << position)
+        else
+          new_bits &= ~(1 << position)
+        end
+        @writer&.write(new_bits)
+        @bits = new_bits
+        init_vars
+      end
+    end
+
+    alias_method :can_administrate=, :can_administrator=
+    alias_method :administrate, :administrator
+
+    attr_reader :bits
+
+    # Set the raw bitset of this permission object
+    # @param bits [Integer] A number whose binary representation is the desired bitset.
+    def bits=(bits)
+      @bits = bits
+      init_vars
+    end
+
+    # Initialize the instance variables based on the bitset.
+    def init_vars
+      FLAGS.each do |position, flag|
+        flag_set = (@bits >> position).allbits?(0x1)
+        instance_variable_set "@#{flag}", flag_set
+      end
+    end
+
+    # Return the corresponding bits for an array of permission flag symbols.
+    # This is a class method that can be used to calculate bits instead
+    # of instancing a new Permissions object.
+    # @example Get the bits for permissions that could allow/deny read messages, connect, and speak
+    #   Permissions.bits [:read_messages, :connect, :speak] #=> 3146752
+    # @param list [Array<Symbol>]
+    # @return [Integer] the computed permissions integer
+    def self.bits(list)
+      value = 0
+
+      FLAGS.each do |position, flag|
+        value += 2**position if list.include? flag
+      end
+
+      value
+    end
+
+    # Create a new Permissions object either as a blank slate to add permissions to (for example for
+    #   {Channel#define_overwrite}) or from existing bit data to read out.
+    # @example Create a permissions object that could allow/deny read messages, connect, and speak by setting flags
+    #   permission = Permissions.new
+    #   permission.can_read_messages = true
+    #   permission.can_connect = true
+    #   permission.can_speak = true
+    # @example Create a permissions object that could allow/deny read messages, connect, and speak by an array of symbols
+    #   Permissions.new [:read_messages, :connect, :speak]
+    # @param bits [String, Integer, Array<Symbol>] The permission bits that should be set from the beginning, or an array of permission flag symbols
+    # @param writer [RoleWriter] The writer that should be used to update data when a permission is set.
+    def initialize(bits = 0, writer = nil)
+      @writer = writer
+
+      @bits = if bits.is_a? Array
+                self.class.bits(bits)
+              else
+                bits.to_i
+              end
+
+      init_vars
+    end
+
+    # Return an array of permission flag symbols for this class's permissions
+    # @example Get the permissions for the bits "9"
+    #   permissions = Permissions.new(9)
+    #   permissions.defined_permissions #=> [:create_instant_invite, :administrator]
+    # @return [Array<Symbol>] the permissions
+    def defined_permissions
+      FLAGS.filter_map { |value, name| @bits.anybits?((1 << value)) ? name : nil }
+    end
+
+    # Comparison based on permission bits
+    def ==(other)
+      return false unless other.is_a?(OnyxCord::Permissions)
+
+      bits == other.bits
+    end
+  end
+
+  # Mixin to calculate resulting permissions from overrides etc.
+  module PermissionCalculator
+    # Checks whether this user can do the particular action, regardless of whether it has the permission defined,
+    # through for example being the server owner or having the Manage Roles permission
+    # @param action [Symbol] The permission that should be checked. See also {Permissions::FLAGS} for a list.
+    # @param channel [Channel, nil] If channel overrides should be checked too, this channel specifies where the overrides should be checked.
+    # @example Check if the bot can send messages to a specific channel in a server.
+    #   bot_profile = bot.profile.on(event.server)
+    #   can_send_messages = bot_profile.permission?(:send_messages, channel)
+    # @return [true, false] whether or not this user has the permission.
+    def permission?(action, channel = nil)
+      # If the member is the server owner, it irrevocably has all permissions.
+      return true if owner?
+
+      # First, check whether the user has Manage Roles defined.
+      # (Coincidentally, Manage Permissions is the same permission as Manage Roles, and a
+      # Manage Permissions deny overwrite will override Manage Roles, so we can just check for
+      # Manage Roles once and call it a day.)
+      return true if defined_permission?(:administrator, channel)
+
+      # Otherwise, defer to defined_permission
+      defined_permission?(action, channel)
+    end
+
+    # Checks whether this user has a particular permission defined (i.e. not implicit, through for example
+    # Manage Roles)
+    # @param action [Symbol] The permission that should be checked. See also {Permissions::FLAGS} for a list.
+    # @param channel [Channel, nil] If channel overrides should be checked too, this channel specifies where the overrides should be checked.
+    # @example Check if a member has the Manage Channels permission defined in the server.
+    #   has_manage_channels = member.defined_permission?(:manage_channels)
+    # @return [true, false] whether or not this user has the permission defined.
+    def defined_permission?(action, channel = nil)
+      # For slash commands we may not have access to the server or role
+      # permissions. In this case we use the permissions given to us by the
+      # interaction. If attempting to check against a specific channel the check
+      # is skipped.
+      return @permissions.__send__(action) if @permissions && channel.nil?
+
+      # Get the permission the user's roles have
+      role_permission = defined_role_permission?(action, channel)
+
+      # Once we have checked the role permission, we have to check the channel overrides for the
+      # specific user
+      user_specific_override = permission_overwrite(action, channel, id) # Use the ID reader as members have no ID instance variable
+
+      # Merge the two permissions - if an override is defined, it has to be allow, otherwise we only care about the role
+      return role_permission unless user_specific_override
+
+      user_specific_override == :allow
+    end
+
+    # Define methods for querying permissions
+    OnyxCord::Permissions::FLAGS.each_value do |flag|
+      define_method "can_#{flag}?" do |channel = nil|
+        permission? flag, channel
+      end
+    end
+
+    alias_method :can_administrate?, :can_administrator?
+
+    private
+
+    def defined_role_permission?(action, channel)
+      roles_to_check = [@server.everyone_role] + roles
+
+      # For each role, check if
+      #   (1) the channel explicitly allows or permits an action for the role and
+      #   (2) if the user is allowed to do the action if the channel doesn't specify
+      roles_to_check.sort_by(&:position).reduce(false) do |can_act, role|
+        # Get the override defined for the role on the channel
+        channel_allow = permission_overwrite(action, channel, role.id)
+        if channel_allow
+          # If the channel has an override, check whether it is an allow - if yes,
+          # the user can act, if not, it can't
+          break true if channel_allow == :allow
+
+          false
+        else
+          # Otherwise defer to the role
+          role.permissions.instance_variable_get("@#{action}") || can_act
+        end
+      end
+    end
+
+    def permission_overwrite(action, channel, id)
+      # If no overwrites are defined, or no channel is set, no overwrite will be present
+      return nil unless channel && channel.permission_overwrites[id]
+
+      # Otherwise, check the allow and deny objects
+      allow = channel.permission_overwrites[id].allow
+      deny = channel.permission_overwrites[id].deny
+      if allow.instance_variable_get("@#{action}")
+        :allow
+      elsif deny.instance_variable_get("@#{action}")
+        :deny
+      end
+
+      # If there's no variable defined, nil will implicitly be returned
+    end
+  end
+end

data/lib/onyxcord/rate_limiter/gateway.rb

@@ -0,0 +1,42 @@
+# 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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require '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
+      def initialize
+        @route_buckets = {}
+        @bucket_mutexes = {}
+        @global_mutex = Mutex.new
+      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]
+
+        @route_buckets[route_key(route, major_parameter)] = bucket_key(bucket, major_parameter) if bucket
+
+        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
+
+      private
+
+      def mutex_for(route, major_parameter)
+        @bucket_mutexes[resolved_key(route, major_parameter)] ||= 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 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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# OnyxCord and all its functionality, in this case only the version.
+module OnyxCord
+  # The current version of onyxcord.
+  VERSION = '1.1.0'
+end

data/lib/onyxcord/voice/encoder.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# This makes opus an optional dependency
+begin
+  require 'opus-ruby'
+  OPUS_AVAILABLE = true
+rescue LoadError
+  OPUS_AVAILABLE = false
+end
+
+# Discord voice chat support
+module OnyxCord::Voice
+  # This class conveniently abstracts opus and ffmpeg/avconv, for easy implementation of voice sending. It's not very
+  # useful for most users, but I guess it can be useful sometimes.
+  class Encoder
+    # Whether or not avconv should be used instead of ffmpeg. If possible, it is recommended to use ffmpeg instead,
+    # as it is better supported.
+    # @return [true, false] whether avconv should be used instead of ffmpeg.
+    attr_accessor :use_avconv
+
+    # @see VoiceBot#filter_volume=
+    # @return [Integer] the volume used as a filter to ffmpeg/avconv.
+    attr_accessor :filter_volume
+
+    # Create a new encoder
+    def initialize
+      sample_rate = 48_000
+      frame_size = 960
+      channels = 2
+      @filter_volume = 1
+
+      raise LoadError, 'Opus unavailable - voice not supported! Please install opus for voice support to work.' unless OPUS_AVAILABLE
+
+      @opus = Opus::Encoder.new(sample_rate, frame_size, channels)
+    end
+
+    # Set the opus encoding bitrate
+    # @param value [Integer] The new bitrate to use, in bits per second (so 64000 if you want 64 kbps)
+    def bitrate=(value)
+      @opus.bitrate = value
+    end
+
+    # Encodes the given buffer using opus.
+    # @param buffer [String] An unencoded PCM (s16le) buffer.
+    # @return [String] A buffer encoded using opus.
+    def encode(buffer)
+      @opus.encode(buffer, 1920)
+    end
+
+    # One frame of complete silence Opus encoded
+    OPUS_SILENCE = [0xF8, 0xFF, 0xFE].pack('C*').freeze
+
+    # Adjusts the volume of a given buffer of s16le PCM data.
+    # @param buf [String] An unencoded PCM (s16le) buffer.
+    # @param mult [Float] The volume multiplier, 1 for same volume.
+    # @return [String] The buffer with adjusted volume, s16le again
+    def adjust_volume(buf, mult)
+      # We don't need to adjust anything if the buf is nil so just return in that case
+      return unless buf
+
+      # buf is s16le so use 's<' for signed, 16 bit, LE
+      result = buf.unpack('s<*').map do |sample|
+        sample *= mult
+
+        # clamp to s16 range
+        [32_767, [-32_768, sample].max].min
+      end
+
+      # After modification, make it s16le again
+      result.pack('s<*')
+    end
+
+    # Encodes a given file (or rather, decodes it) using ffmpeg. This accepts pretty much any format, even videos with
+    # an audio track. For a list of supported formats, see https://ffmpeg.org/general.html#Audio-Codecs. It even accepts
+    # URLs, though encoding them is pretty slow - I recommend to make a stream of it and then use {#encode_io} instead.
+    # @param file [String] The path or URL to encode.
+    # @param options [String] ffmpeg options to pass after the -i flag
+    # @return [IO] the audio, encoded as s16le PCM
+    def encode_file(file, options = '')
+      command = ffmpeg_command(input: file, options: options)
+      IO.popen(command)
+    end
+
+    # Encodes an arbitrary IO audio stream using ffmpeg. Accepts pretty much any media format, even videos with audio
+    # tracks. For a list of supported audio formats, see https://ffmpeg.org/general.html#Audio-Codecs.
+    # @param io [IO] The stream to encode.
+    # @param options [String] ffmpeg options to pass after the -i flag
+    # @return [IO] the audio, encoded as s16le PCM
+    def encode_io(io, options = '')
+      command = ffmpeg_command(options: options)
+      IO.popen(command, in: io)
+    end
+
+    private
+
+    def ffmpeg_command(input: '-', options: null)
+      [
+        @use_avconv ? 'avconv' : 'ffmpeg',
+        '-loglevel', '0',
+        '-i', input,
+        '-f', 's16le',
+        '-ar', '48000',
+        '-ac', '2',
+        'pipe:1',
+        filter_volume_argument
+      ].concat(options.split).reject { |segment| segment.nil? || segment == '' }
+    end
+
+    def filter_volume_argument
+      return '' if @filter_volume == 1
+
+      @use_avconv ? "-vol #{(@filter_volume * 256).ceil}" : "-af volume=#{@filter_volume}"
+    end
+  end
+end