discordrb 3.3.0 → 3.4.3

data/lib/discordrb/data/member.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # Mixin for the attributes members and private members should have
+  module MemberAttributes
+    # @return [Time] when this member joined the server.
+    attr_reader :joined_at
+
+    # @return [Time, nil] when this member boosted this server, `nil` if they haven't.
+    attr_reader :boosting_since
+
+    # @return [String, nil] the nickname this member has, or `nil` if it has none.
+    attr_reader :nick
+    alias_method :nickname, :nick
+
+    # @return [Array<Role>] the roles this member has.
+    attr_reader :roles
+
+    # @return [Server] the server this member is on.
+    attr_reader :server
+  end
+
+  # A member is a user on a server. It differs from regular users in that it has roles, voice statuses and things like
+  # that.
+  class Member < DelegateClass(User)
+    # @return [true, false] whether this member is muted server-wide.
+    def mute
+      voice_state_attribute(:mute)
+    end
+
+    # @return [true, false] whether this member is deafened server-wide.
+    def deaf
+      voice_state_attribute(:deaf)
+    end
+
+    # @return [true, false] whether this member has muted themselves.
+    def self_mute
+      voice_state_attribute(:self_mute)
+    end
+
+    # @return [true, false] whether this member has deafened themselves.
+    def self_deaf
+      voice_state_attribute(:self_deaf)
+    end
+
+    # @return [Channel] the voice channel this member is in.
+    def voice_channel
+      voice_state_attribute(:voice_channel)
+    end
+
+    alias_method :muted?, :mute
+    alias_method :deafened?, :deaf
+    alias_method :self_muted?, :self_mute
+    alias_method :self_deafened?, :self_deaf
+
+    include MemberAttributes
+
+    # @!visibility private
+    def initialize(data, server, bot)
+      @bot = bot
+
+      @user = bot.ensure_user(data['user'])
+      super @user # Initialize the delegate class
+
+      # Somehow, Discord doesn't send the server ID in the standard member format...
+      raise ArgumentError, 'Cannot create a member without any information about the server!' if server.nil? && data['guild_id'].nil?
+
+      @server = server || bot.server(data['guild_id'].to_i)
+
+      # Initialize the roles by getting the roles from the server one-by-one
+      update_roles(data['roles'])
+
+      @nick = data['nick']
+      @joined_at = data['joined_at'] ? Time.parse(data['joined_at']) : nil
+      @boosting_since = data['premium_since'] ? Time.parse(data['premium_since']) : nil
+    end
+
+    # @return [true, false] if this user is a Nitro Booster of this server.
+    def boosting?
+      !@boosting_since.nil?
+    end
+
+    # @return [true, false] whether this member is the server owner.
+    def owner?
+      @server.owner == self
+    end
+
+    # @param role [Role, String, Integer] the role to check or its ID.
+    # @return [true, false] whether this member has the specified role.
+    def role?(role)
+      role = role.resolve_id
+      @roles.any? { |e| e.id == role }
+    end
+
+    # @see Member#set_roles
+    def roles=(role)
+      set_roles(role)
+    end
+
+    # Bulk sets a member's roles.
+    # @param role [Role, Array<Role>] The role(s) to set.
+    # @param reason [String] The reason the user's roles are being changed.
+    def set_roles(role, reason = nil)
+      role_ids = role_id_array(role)
+      API::Server.update_member(@bot.token, @server.id, @user.id, roles: role_ids, reason: reason)
+    end
+
+    # Adds and removes roles from a member.
+    # @param add [Role, Array<Role>] The role(s) to add.
+    # @param remove [Role, Array<Role>] The role(s) to remove.
+    # @param reason [String] The reason the user's roles are being changed.
+    # @example Remove the 'Member' role from a user, and add the 'Muted' role to them.
+    #   to_add = server.roles.find {|role| role.name == 'Muted'}
+    #   to_remove = server.roles.find {|role| role.name == 'Member'}
+    #   member.modify_roles(to_add, to_remove)
+    def modify_roles(add, remove, reason = nil)
+      add_role_ids = role_id_array(add)
+      remove_role_ids = role_id_array(remove)
+      old_role_ids = @roles.map(&:id)
+      new_role_ids = (old_role_ids - remove_role_ids + add_role_ids).uniq
+
+      API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids, reason: reason)
+    end
+
+    # Adds one or more roles to this member.
+    # @param role [Role, Array<Role, String, Integer>, String, Integer] The role(s), or their ID(s), to add.
+    # @param reason [String] The reason the user's roles are being changed.
+    def add_role(role, reason = nil)
+      role_ids = role_id_array(role)
+
+      if role_ids.count == 1
+        API::Server.add_member_role(@bot.token, @server.id, @user.id, role_ids[0], reason)
+      else
+        old_role_ids = @roles.map(&:id)
+        new_role_ids = (old_role_ids + role_ids).uniq
+        API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids, reason: reason)
+      end
+    end
+
+    # Removes one or more roles from this member.
+    # @param role [Role, Array<Role>] The role(s) to remove.
+    # @param reason [String] The reason the user's roles are being changed.
+    def remove_role(role, reason = nil)
+      role_ids = role_id_array(role)
+
+      if role_ids.count == 1
+        API::Server.remove_member_role(@bot.token, @server.id, @user.id, role_ids[0], reason)
+      else
+        old_role_ids = @roles.map(&:id)
+        new_role_ids = old_role_ids.reject { |i| role_ids.include?(i) }
+        API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids, reason: reason)
+      end
+    end
+
+    # @return [Role] the highest role this member has.
+    def highest_role
+      @roles.max_by(&:position)
+    end
+
+    # @return [Role, nil] the role this member is being hoisted with.
+    def hoist_role
+      hoisted_roles = @roles.select(&:hoist)
+      return nil if hoisted_roles.empty?
+
+      hoisted_roles.max_by(&:position)
+    end
+
+    # @return [Role, nil] the role this member is basing their colour on.
+    def colour_role
+      coloured_roles = @roles.select { |v| v.colour.combined.nonzero? }
+      return nil if coloured_roles.empty?
+
+      coloured_roles.max_by(&:position)
+    end
+    alias_method :color_role, :colour_role
+
+    # @return [ColourRGB, nil] the colour this member has.
+    def colour
+      return nil unless colour_role
+
+      colour_role.color
+    end
+    alias_method :color, :colour
+
+    # Server deafens this member.
+    def server_deafen
+      API::Server.update_member(@bot.token, @server.id, @user.id, deaf: true)
+    end
+
+    # Server undeafens this member.
+    def server_undeafen
+      API::Server.update_member(@bot.token, @server.id, @user.id, deaf: false)
+    end
+
+    # Server mutes this member.
+    def server_mute
+      API::Server.update_member(@bot.token, @server.id, @user.id, mute: true)
+    end
+
+    # Server unmutes this member.
+    def server_unmute
+      API::Server.update_member(@bot.token, @server.id, @user.id, mute: false)
+    end
+
+    # @see Member#set_nick
+    def nick=(nick)
+      set_nick(nick)
+    end
+
+    alias_method :nickname=, :nick=
+
+    # Sets or resets this member's nickname. Requires the Change Nickname permission for the bot itself and Manage
+    # Nicknames for other users.
+    # @param nick [String, nil] The string to set the nickname to, or nil if it should be reset.
+    # @param reason [String] The reason the user's nickname is being changed.
+    def set_nick(nick, reason = nil)
+      # Discord uses the empty string to signify 'no nickname' so we convert nil into that
+      nick ||= ''
+
+      if @user.current_bot?
+        API::User.change_own_nickname(@bot.token, @server.id, nick, reason)
+      else
+        API::Server.update_member(@bot.token, @server.id, @user.id, nick: nick, reason: nil)
+      end
+    end
+
+    alias_method :set_nickname, :set_nick
+
+    # @return [String] the name the user displays as (nickname if they have one, username otherwise)
+    def display_name
+      nickname || username
+    end
+
+    # Update this member's roles
+    # @note For internal use only.
+    # @!visibility private
+    def update_roles(role_ids)
+      @roles = [@server.role(@server.id)]
+      role_ids.each do |id|
+        # It is possible for members to have roles that do not exist
+        # on the server any longer. See https://github.com/shardlab/discordrb/issues/371
+        role = @server.role(id)
+        @roles << role if role
+      end
+    end
+
+    # Update this member's nick
+    # @note For internal use only.
+    # @!visibility private
+    def update_nick(nick)
+      @nick = nick
+    end
+
+    # Update this member's boosting timestamp
+    # @note For internal user only.
+    # @!visibility private
+    def update_boosting_since(time)
+      @boosting_since = time
+    end
+
+    # Update this member
+    # @note For internal use only.
+    # @!visibility private
+    def update_data(data)
+      update_roles(data['roles']) if data['roles']
+      update_nick(data['nick']) if data.key?('nick')
+      @mute = data['mute'] if data.key?('mute')
+      @deaf = data['deaf'] if data.key?('deaf')
+
+      @joined_at = Time.parse(data['joined_at']) if data['joined_at']
+    end
+
+    include PermissionCalculator
+
+    # Overwriting inspect for debug purposes
+    def inspect
+      "<Member user=#{@user.inspect} server=#{@server.inspect} joined_at=#{@joined_at} roles=#{@roles.inspect} voice_channel=#{@voice_channel.inspect} mute=#{@mute} deaf=#{@deaf} self_mute=#{@self_mute} self_deaf=#{@self_deaf}>"
+    end
+
+    private
+
+    # Utility method to get a list of role IDs from one role or an array of roles
+    def role_id_array(role)
+      if role.is_a? Array
+        role.map(&:resolve_id)
+      else
+        [role.resolve_id]
+      end
+    end
+
+    # Utility method to get data out of this member's voice state
+    def voice_state_attribute(name)
+      voice_state = @server.voice_states[@user.id]
+      voice_state&.send name
+    end
+  end
+end

data/lib/discordrb/data/message.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # A message on Discord that was sent to a text channel
+  class Message
+    include IDObject
+
+    # @return [String] the content of this message.
+    attr_reader :content
+    alias_method :text, :content
+    alias_method :to_s, :content
+
+    # @return [Member, User] the user that sent this message. (Will be a {Member} most of the time, it should only be a
+    #   {User} for old messages when the author has left the server since then)
+    attr_reader :author
+    alias_method :user, :author
+    alias_method :writer, :author
+
+    # @return [Channel] the channel in which this message was sent.
+    attr_reader :channel
+
+    # @return [Time] the timestamp at which this message was sent.
+    attr_reader :timestamp
+
+    # @return [Time] the timestamp at which this message was edited. `nil` if the message was never edited.
+    attr_reader :edited_timestamp
+    alias_method :edit_timestamp, :edited_timestamp
+
+    # @return [Array<User>] the users that were mentioned in this message.
+    attr_reader :mentions
+
+    # @return [Array<Role>] the roles that were mentioned in this message.
+    attr_reader :role_mentions
+
+    # @return [Array<Attachment>] the files attached to this message.
+    attr_reader :attachments
+
+    # @return [Array<Embed>] the embed objects contained in this message.
+    attr_reader :embeds
+
+    # @return [Array<Reaction>] the reaction objects contained in this message.
+    attr_reader :reactions
+
+    # @return [true, false] whether the message used Text-To-Speech (TTS) or not.
+    attr_reader :tts
+    alias_method :tts?, :tts
+
+    # @return [String] used for validating a message was sent.
+    attr_reader :nonce
+
+    # @return [true, false] whether the message was edited or not.
+    attr_reader :edited
+    alias_method :edited?, :edited
+
+    # @return [true, false] whether the message mentioned everyone or not.
+    attr_reader :mention_everyone
+    alias_method :mention_everyone?, :mention_everyone
+    alias_method :mentions_everyone?, :mention_everyone
+
+    # @return [true, false] whether the message is pinned or not.
+    attr_reader :pinned
+    alias_method :pinned?, :pinned
+
+    # @return [Server, nil] the server in which this message was sent.
+    attr_reader :server
+
+    # @return [Integer, nil] the webhook ID that sent this message, or `nil` if it wasn't sent through a webhook.
+    attr_reader :webhook_id
+
+    # The discriminator that webhook user accounts have.
+    ZERO_DISCRIM = '0000'
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @content = data['content']
+      @channel = bot.channel(data['channel_id'].to_i)
+      @pinned = data['pinned']
+      @tts = data['tts']
+      @nonce = data['nonce']
+      @mention_everyone = data['mention_everyone']
+
+      @referenced_message = Message.new(data['referenced_message'], bot) if data['referenced_message']
+      @message_reference = data['message_reference']
+
+      @server = @channel.server
+
+      @author = if data['author']
+                  if data['author']['discriminator'] == ZERO_DISCRIM
+                    # This is a webhook user! It would be pointless to try to resolve a member here, so we just create
+                    # a User and return that instead.
+                    Discordrb::LOGGER.debug("Webhook user: #{data['author']['id']}")
+                    User.new(data['author'], @bot)
+                  elsif @channel.private?
+                    # Turn the message user into a recipient - we can't use the channel recipient
+                    # directly because the bot may also send messages to the channel
+                    Recipient.new(bot.user(data['author']['id'].to_i), @channel, bot)
+                  else
+                    member = @channel.server.member(data['author']['id'].to_i)
+
+                    if member
+                      member.update_data(data['member']) if data['member']
+                    else
+                      Discordrb::LOGGER.debug("Member with ID #{data['author']['id']} not cached (possibly left the server).")
+                      member = if data['member']
+                                 member_data = data['author'].merge(data['member'])
+                                 Member.new(member_data, bot)
+                               else
+                                 @bot.ensure_user(data['author'])
+                               end
+                    end
+
+                    member
+                  end
+                end
+
+      @webhook_id = data['webhook_id'].to_i if data['webhook_id']
+
+      @timestamp = Time.parse(data['timestamp']) if data['timestamp']
+      @edited_timestamp = data['edited_timestamp'].nil? ? nil : Time.parse(data['edited_timestamp'])
+      @edited = !@edited_timestamp.nil?
+      @id = data['id'].to_i
+
+      @emoji = []
+
+      @reactions = []
+
+      data['reactions']&.each do |element|
+        @reactions << Reaction.new(element)
+      end
+
+      @mentions = []
+
+      data['mentions']&.each do |element|
+        @mentions << bot.ensure_user(element)
+      end
+
+      @role_mentions = []
+
+      # Role mentions can only happen on public servers so make sure we only parse them there
+      if @channel.text?
+        data['mention_roles']&.each do |element|
+          @role_mentions << @channel.server.role(element.to_i)
+        end
+      end
+
+      @attachments = []
+      @attachments = data['attachments'].map { |e| Attachment.new(e, self, @bot) } if data['attachments']
+
+      @embeds = []
+      @embeds = data['embeds'].map { |e| Embed.new(e, self) } if data['embeds']
+    end
+
+    # Replies to this message with the specified content.
+    # @deprecated Please use {#respond}.
+    # @see Channel#send_message
+    def reply(content)
+      @channel.send_message(content)
+    end
+
+    # Sends a message to this channel.
+    # @param content [String] The content to send. Should not be longer than 2000 characters or it will result in an error.
+    # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
+    # @param embed [Hash, Discordrb::Webhooks::Embed, nil] The rich embed to append to this message.
+    # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
+    # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
+    # @param mention_user [true, false] Whether the user that is being replied to should be pinged by the reply.
+    # @return [Message] the message that was sent.
+    def reply!(content, tts: false, embed: nil, attachments: nil, allowed_mentions: {}, mention_user: false)
+      allowed_mentions = { parse: [] } if allowed_mentions == false
+      allowed_mentions = allowed_mentions.to_hash.transform_keys(&:to_sym)
+      allowed_mentions[:replied_user] = mention_user
+
+      respond(content, tts, embed, attachments, allowed_mentions, self)
+    end
+
+    # (see Channel#send_message)
+    def respond(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil)
+      @channel.send_message(content, tts, embed, attachments, allowed_mentions, message_reference)
+    end
+
+    # Edits this message to have the specified content instead.
+    # You can only edit your own messages.
+    # @param new_content [String] the new content the message should have.
+    # @param new_embed [Hash, Discordrb::Webhooks::Embed, nil] The new embed the message should have. If `nil` the message will be changed to have no embed.
+    # @return [Message] the resulting message.
+    def edit(new_content, new_embed = nil)
+      response = API::Channel.edit_message(@bot.token, @channel.id, @id, new_content, [], new_embed ? new_embed.to_hash : nil)
+      Message.new(JSON.parse(response), @bot)
+    end
+
+    # Deletes this message.
+    def delete(reason = nil)
+      API::Channel.delete_message(@bot.token, @channel.id, @id, reason)
+      nil
+    end
+
+    # Pins this message
+    def pin(reason = nil)
+      API::Channel.pin_message(@bot.token, @channel.id, @id, reason)
+      @pinned = true
+      nil
+    end
+
+    # Unpins this message
+    def unpin(reason = nil)
+      API::Channel.unpin_message(@bot.token, @channel.id, @id, reason)
+      @pinned = false
+      nil
+    end
+
+    # Add an {Await} for a message with the same user and channel.
+    # @see Bot#add_await
+    # @deprecated Will be changed to blocking behavior in v4.0. Use {#await!} instead.
+    def await(key, attributes = {}, &block)
+      @bot.add_await(key, Discordrb::Events::MessageEvent, { from: @author.id, in: @channel.id }.merge(attributes), &block)
+    end
+
+    # Add a blocking {Await} for a message with the same user and channel.
+    # @see Bot#add_await!
+    def await!(attributes = {}, &block)
+      @bot.add_await!(Discordrb::Events::MessageEvent, { from: @author.id, in: @channel.id }.merge(attributes), &block)
+    end
+
+    # @return [true, false] whether this message was sent by the current {Bot}.
+    def from_bot?
+      @author&.current_bot?
+    end
+
+    # @return [true, false] whether this message has been sent over a webhook.
+    def webhook?
+      !@webhook_id.nil?
+    end
+
+    # @return [Array<Emoji>] the emotes that were used/mentioned in this message.
+    def emoji
+      return if @content.nil?
+      return @emoji unless @emoji.empty?
+
+      @emoji = @bot.parse_mentions(@content).select { |el| el.is_a? Discordrb::Emoji }
+    end
+
+    # Check if any emoji were used in this message.
+    # @return [true, false] whether or not any emoji were used
+    def emoji?
+      emoji&.empty?
+    end
+
+    # Check if any reactions were used in this message.
+    # @return [true, false] whether or not this message has reactions
+    def reactions?
+      !@reactions.empty?
+    end
+
+    # Returns the reactions made by the current bot or user.
+    # @return [Array<Reaction>] the reactions
+    def my_reactions
+      @reactions.select(&:me)
+    end
+
+    # Reacts to a message.
+    # @param reaction [String, #to_reaction] the unicode emoji or {Emoji}
+    def create_reaction(reaction)
+      reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
+      API::Channel.create_reaction(@bot.token, @channel.id, @id, reaction)
+      nil
+    end
+
+    alias_method :react, :create_reaction
+
+    # Returns the list of users who reacted with a certain reaction.
+    # @param reaction [String, #to_reaction] the unicode emoji or {Emoji}
+    # @param limit [Integer] the limit of how many users to retrieve. `nil` will return all users
+    # @example Get all the users that reacted with a thumbs up.
+    #   thumbs_up_reactions = message.reacted_with("\u{1F44D}")
+    # @return [Array<User>] the users who used this reaction
+    def reacted_with(reaction, limit: 100)
+      reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
+      paginator = Paginator.new(limit, :down) do |last_page|
+        after_id = last_page.last.id if last_page
+        last_page = JSON.parse(API::Channel.get_reactions(@bot.token, @channel.id, @id, reaction, nil, after_id, limit))
+        last_page.map { |d| User.new(d, @bot) }
+      end
+      paginator.to_a
+    end
+
+    # Deletes a reaction made by a user on this message.
+    # @param user [User, String, Integer] the user or user ID who used this reaction
+    # @param reaction [String, #to_reaction] the reaction to remove
+    def delete_reaction(user, reaction)
+      reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
+      API::Channel.delete_user_reaction(@bot.token, @channel.id, @id, reaction, user.resolve_id)
+    end
+
+    # Deletes this client's reaction on this message.
+    # @param reaction [String, #to_reaction] the reaction to remove
+    def delete_own_reaction(reaction)
+      reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
+      API::Channel.delete_own_reaction(@bot.token, @channel.id, @id, reaction)
+    end
+
+    # Removes all reactions from this message.
+    def delete_all_reactions
+      API::Channel.delete_all_reactions(@bot.token, @channel.id, @id)
+    end
+
+    # The inspect method is overwritten to give more useful output
+    def inspect
+      "<Message content=\"#{@content}\" id=#{@id} timestamp=#{@timestamp} author=#{@author} channel=#{@channel}>"
+    end
+
+    # @return [String] a URL that a user can use to navigate to this message in the client
+    def link
+      "https://discord.com/channels/#{@server&.id || '@me'}/#{@channel.id}/#{@id}"
+    end
+
+    alias_method :jump_link, :link
+
+    # Whether or not this message was sent in reply to another message
+    # @return [true, false]
+    def reply?
+      !@referenced_message.nil?
+    end
+
+    # @return [Message, nil] the Message this Message was sent in reply to.
+    def referenced_message
+      return @referenced_message if @referenced_message
+      return nil unless @message_reference
+
+      referenced_channel = @bot.channel(@message_reference['channel_id'])
+      @referenced_message = referenced_channel.message(@message_reference['message_id'])
+    end
+  end
+end