discordrb 3.4.0 → 3.5.0

data/lib/discordrb/events/threads.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Discordrb::Events
+  # Raised when a thread is created
+  class ThreadCreateEvent < Event
+    # @return [Channel] the thread in question.
+    attr_reader :thread
+
+    delegate :name, :server, :owner, :parent_channel, :thread_metadata, to: :thread
+
+    def initialize(data, bot)
+      @bot = bot
+      @thread = data.is_a?(Discordrb::Channel) ? data : bot.channel(data['id'].to_i)
+    end
+  end
+
+  # Event handler for ChannelCreateEvent
+  class ThreadCreateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ThreadCreateEvent
+
+      [
+        matches_all(@attributes[:name], event.name) do |a, e|
+          a == if a.is_a? String
+                 e.to_s
+               else
+                 e
+               end
+        end,
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a.resolve_id == e.resolve_id
+        end,
+        matches_all(@attributes[:invitable], event.thread.invitable) do |a, e|
+          a == e
+        end,
+        matches_all(@attributes[:owner], event.thread.owner) do |a, e|
+          a.resolve_id == e.resolve_id
+        end,
+        matches_all(@attributes[:channel], event.thread.parent) do |a, e|
+          a.resolve_id == e.resolve_id
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Raised when a thread is updated (e.g. name changes)
+  class ThreadUpdateEvent < ThreadCreateEvent; end
+
+  # Event handler for ThreadUpdateEvent
+  class ThreadUpdateEventHandler < ThreadCreateEventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ThreadUpdateEvent
+
+      super
+    end
+  end
+
+  # Raised when members are added or removed from a thread.
+  class ThreadMembersUpdateEvent < Event
+    # @return [Channel]
+    attr_reader :thread
+
+    # @return [Array<Member, User>]
+    attr_reader :added_members
+
+    # @return [Array<Integer>]
+    attr_reader :removed_member_ids
+
+    # @return [Integer]
+    attr_reader :member_count
+
+    delegate :name, :server, :owner, :parent_channel, :thread_metadata, to: :thread
+
+    def initialize(data, bot)
+      @bot = bot
+      @thread = data.is_a?(Discordrb::Channel) ? data : bot.channel(data['id'].to_i)
+      @added_members = data['added_members']&.map do |member|
+        data['guild_id'] ? bot.member(data['guild_id'], member['user_id']) : bot.user(member['user_id'])
+      end || []
+      @removed_member_ids = data['removed_member_ids']&.map(&:resolve_id) || []
+      @member_count = data['member_count']
+    end
+  end
+
+  # Event handler for ThreadMembersUpdateEvent
+  class ThreadMembersUpdateEventHandler < ThreadCreateEventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ThreadMembersUpdateEvent
+
+      super
+    end
+  end
+end

data/lib/discordrb/gateway.rb

@@ -134,7 +134,7 @@ module Discordrb
     LARGE_THRESHOLD = 100
 
     # The version of the gateway that's supposed to be used.
-    GATEWAY_VERSION = 6
+    GATEWAY_VERSION = 9
 
     # Heartbeat ACKs are Discord's way of verifying on the client side whether the connection is still alive. If this is
     # set to true (default value) the gateway client will use that functionality to detect zombie connections and
@@ -143,7 +143,10 @@ module Discordrb
     # @return [true, false] whether or not this gateway should check for heartbeat ACKs.
     attr_accessor :check_heartbeat_acks
 
-    def initialize(bot, token, shard_key = nil, compress_mode = :stream, intents = nil)
+    # @return [Integer] the intent parameter sent to the gateway server.
+    attr_reader :intents
+
+    def initialize(bot, token, shard_key = nil, compress_mode = :stream, intents = ALL_INTENTS)
       @token = token
       @bot = bot
 
@@ -277,12 +280,12 @@ module Discordrb
     def identify
       compress = @compress_mode == :large
       send_identify(@token, {
-                      '$os': RUBY_PLATFORM,
-                      '$browser': 'discordrb',
-                      '$device': 'discordrb',
-                      '$referrer': '',
-                      '$referring_domain': ''
-                    }, compress, 100, @shard_key)
+                      os: RUBY_PLATFORM,
+                      browser: 'discordrb',
+                      device: 'discordrb',
+                      referrer: '',
+                      referring_domain: ''
+                    }, compress, LARGE_THRESHOLD, @shard_key, @intents)
     end
 
     # Sends an identify packet (op 2). This starts a new session on the current connection and tells Discord who we are.
@@ -292,26 +295,26 @@ module Discordrb
     # @param properties [Hash<Symbol => String>] A list of properties for Discord to use in analytics. The following
     #   keys are recognised:
     #
-    #    - "$os" (recommended value: the operating system the bot is running on)
-    #    - "$browser" (recommended value: library name)
-    #    - "$device" (recommended value: library name)
-    #    - "$referrer" (recommended value: empty)
-    #    - "$referring_domain" (recommended value: empty)
+    #    - "os" (recommended value: the operating system the bot is running on)
+    #    - "browser" (recommended value: library name)
+    #    - "device" (recommended value: library name)
+    #    - "referrer" (recommended value: empty)
+    #    - "referring_domain" (recommended value: empty)
     #
     # @param compress [true, false] Whether certain large packets should be compressed using zlib.
     # @param large_threshold [Integer] The member threshold after which a server counts as large and will have to have
     #   its member list chunked.
     # @param shard_key [Array(Integer, Integer), nil] The shard key to use for sharding, represented as
     #   [shard_id, num_shards], or nil if the bot should not be sharded.
-    def send_identify(token, properties, compress, large_threshold, shard_key = nil)
+    def send_identify(token, properties, compress, large_threshold, shard_key = nil, intents = ALL_INTENTS)
       data = {
         # Don't send a v anymore as it's entirely determined by the URL now
         token: token,
         properties: properties,
         compress: compress,
-        large_threshold: large_threshold
+        large_threshold: large_threshold,
+        intents: intents
       }
-      data[:intents] = @intents unless @intents.nil?
 
       # Don't include the shard key at all if it is nil as Discord checks for its mere existence
       data[:shard] = shard_key if shard_key
@@ -790,7 +793,8 @@ module Discordrb
     # - 4003: Not authenticated. How did this happen?
     # - 4004: Authentication failed. Token was wrong, nothing we can do.
     # - 4011: Sharding required. Currently requires developer intervention.
-    FATAL_CLOSE_CODES = [4003, 4004, 4011].freeze
+    # - 4014: Use of disabled privileged intents.
+    FATAL_CLOSE_CODES = [4003, 4004, 4011, 4014].freeze
 
     def handle_close(e)
       @bot.__send__(:raise_event, Events::DisconnectEvent.new(@bot))
@@ -800,6 +804,15 @@ module Discordrb
         LOGGER.error('Websocket close frame received!')
         LOGGER.error("Code: #{e.code}")
         LOGGER.error("Message: #{e.data}")
+
+        if e.code == 4014
+          LOGGER.error(<<~ERROR)
+            You attempted to identify with privileged intents that your bot is not authorized to use
+            Please enable the privileged intents on the bot page of your application on the discord developer page.
+            Read more here https://discord.com/developers/docs/topics/gateway#privileged-intents
+          ERROR
+        end
+
         @should_reconnect = false if FATAL_CLOSE_CODES.include?(e.code)
       elsif e.is_a? Exception
         # Log the exception

data/lib/discordrb/permissions.rb

@@ -6,37 +6,47 @@ module Discordrb
     # 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
+      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
     }.freeze
 
     FLAGS.each do |position, flag|
@@ -101,7 +111,7 @@ module Discordrb
     #   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 [Integer, Array<Symbol>] The permission bits that should be set from the beginning, or an array of permission flag symbols
+    # @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
@@ -109,12 +119,21 @@ module Discordrb
       @bits = if bits.is_a? Array
                 self.class.bits(bits)
               else
-                bits
+                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 & (1 << value)).positive? ? name : nil }
+    end
+
     # Comparison based on permission bits
     def ==(other)
       false unless other.is_a? Discordrb::Permissions
@@ -154,6 +173,12 @@ module Discordrb
     #   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)
 
@@ -179,7 +204,7 @@ module Discordrb
     private
 
     def defined_role_permission?(action, channel)
-      roles_to_check = [@server.everyone_role] + @roles
+      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

data/lib/discordrb/version.rb

@@ -3,5 +3,5 @@
 # Discordrb and all its functionality, in this case only the version.
 module Discordrb
   # The current version of discordrb.
-  VERSION = '3.4.0'
+  VERSION = '3.5.0'
 end

data/lib/discordrb/voice/encoder.rb

@@ -77,7 +77,7 @@ module Discordrb::Voice
     # @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} -loglevel 0 -i \"#{file}\" #{options} -f s16le -ar 48000 -ac 2 #{filter_volume_argument} pipe:1"
+      command = ffmpeg_command(input: file, options: options)
       IO.popen(command)
     end
 
@@ -87,14 +87,23 @@ module Discordrb::Voice
     # @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} -loglevel 0 -i - #{options} -f s16le -ar 48000 -ac 2 #{filter_volume_argument} pipe:1"
+      command = ffmpeg_command(options: options)
       IO.popen(command, in: io)
     end
 
     private
 
-    def ffmpeg_command
-      @use_avconv ? 'avconv' : 'ffmpeg'
+    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

data/lib/discordrb/voice/network.rb

@@ -42,10 +42,10 @@ module Discordrb::Voice
     attr_writer :secret_key
 
     # The UDP encryption mode
-    attr_reader :mode # rubocop:disable Style/BisectedAttrAccessor
+    attr_reader :mode
 
     # @!visibility private
-    attr_writer :mode # rubocop:disable Style/BisectedAttrAccessor
+    attr_writer :mode
 
     # Creates a new UDP connection. Only creates a socket as the discovery reply may come before the data is
     # initialized.
@@ -69,9 +69,9 @@ module Discordrb::Voice
     # @return [Array(String, Integer)] the IP and port received from the discovery reply.
     def receive_discovery_reply
       # Wait for a UDP message
-      message = @socket.recv(70)
-      ip = message[4..-3].delete("\0")
-      port = message[-2..-1].unpack1('n')
+      message = @socket.recv(74)
+      ip = message[8..-3].delete("\0")
+      port = message[-2..].unpack1('n')
       [ip, port]
     end
 
@@ -98,10 +98,21 @@ module Discordrb::Voice
     # Sends the UDP discovery packet with the internally stored SSRC. Discord will send a reply afterwards which can
     # be received using {#receive_discovery_reply}
     def send_discovery
-      discovery_packet = [@ssrc].pack('N')
+      # Create empty packet
+      discovery_packet = ''
 
-      # Add 66 zeroes so the packet is 70 bytes long
+      # Add Type request (0x1 = request, 0x2 = response)
+      discovery_packet += [0x1].pack('n')
+
+      # Add Length (excluding Type and itself = 70)
+      discovery_packet += [70].pack('n')
+
+      # Add SSRC
+      discovery_packet += [@ssrc].pack('N')
+
+      # Add 66 zeroes so the packet is 74 bytes long
       discovery_packet += "\0" * 66
+
       send_packet(discovery_packet)
     end
 

data/lib/discordrb/voice/sodium.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require 'ffi'
+
 module Discordrb::Voice
   # @!visibility private
   module Sodium
-    extend FFI::Library
+    extend ::FFI::Library
 
     ffi_lib(['sodium', 'libsodium.so.18', 'libsodium.so.23'])
 

data/lib/discordrb/voice/voice_bot.rb

@@ -22,10 +22,10 @@ module Discordrb::Voice
   # {VoiceBot#adjust_offset}, and {VoiceBot#adjust_average}.
   class VoiceBot
     # @return [Channel] the current voice channel
-    attr_reader :channel # rubocop:disable Style/BisectedAttrAccessor
+    attr_reader :channel
 
     # @!visibility private
-    attr_writer :channel # rubocop:disable Style/BisectedAttrAccessor
+    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
@@ -149,7 +149,7 @@ module Discordrb::Voice
 
     # 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://discordapp.com/developers/docs/topics/voice-connections#speaking for information on the speaking bitmask
+    # @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)

data/lib/discordrb/webhooks.rb

@@ -4,6 +4,8 @@ require 'discordrb/webhooks/version'
 require 'discordrb/webhooks/embeds'
 require 'discordrb/webhooks/client'
 require 'discordrb/webhooks/builder'
+require 'discordrb/webhooks/view'
+require 'discordrb/webhooks/modal'
 
 module Discordrb
   # Webhook client

data/lib/discordrb.rb

@@ -10,13 +10,13 @@ module Discordrb
   Thread.current[:discordrb_name] = 'main'
 
   # The default debug logger used by discordrb.
-  LOGGER = Logger.new(ENV['DISCORDRB_FANCY_LOG'])
+  LOGGER = Logger.new(ENV.fetch('DISCORDRB_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://discordapp.com/developers/docs/topics/gateway#gateway-intents
+  # @see https://discord.com/developers/docs/topics/gateway#gateway-intents
   INTENTS = {
     servers: 1 << 0,
     server_members: 1 << 1,
@@ -35,9 +35,16 @@ module Discordrb
     direct_message_typing: 1 << 14
   }.freeze
 
-  # @return [Integer] All available intents
+  # 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])
+
+  # 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)
@@ -46,6 +53,18 @@ module Discordrb
   # 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
+  }.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
@@ -76,7 +95,7 @@ module Discordrb
     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..-1].strip
+    rest = msg[ideal.length..].strip
 
     # If none remains, return an empty array -> we're done
     return [] unless rest
@@ -84,6 +103,20 @@ module Discordrb
     # 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
+  #   Discordrb.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
 end
 
 # In discordrb, Integer and {String} are monkey-patched to allow for easy resolution of IDs