discordrb 3.1.1 → 3.4.0

data/lib/discordrb/data/activity.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # Contains information about user activities such as the game they are playing,
+  # music they are listening to, or their live stream.
+  class Activity
+    # Values corresponding to the flags bitmask
+    FLAGS = {
+      instance: 1 << 0, # this activity is an instanced game session
+      join: 1 << 1, # this activity is joinable
+      spectate: 1 << 2, # this activity can be spectated
+      join_request: 1 << 3, # this activity allows asking to join
+      sync: 1 << 4, # this activity is a spotify track
+      play: 1 << 5 # this game can be played or opened from discord
+    }.freeze
+
+    # @return [String] the activity's name
+    attr_reader :name
+
+    # @return [Integer, nil] activity type. Can be {GAME}, {STREAMING}, {LISTENING}, {CUSTOM}
+    attr_reader :type
+
+    # @return [String, nil] stream URL, when the activity type is {STREAMING}
+    attr_reader :url
+
+    # @return [String, nil] the application ID for the game
+    attr_reader :application_id
+
+    # @return [String, nil] details about what the player is currently doing
+    attr_reader :details
+
+    # @return [String, nil] the user's current party status
+    attr_reader :state
+
+    # @return [true, false] whether or not the activity is an instanced game session
+    attr_reader :instance
+
+    # @return [Integer] a bitmask of activity flags
+    # @see FLAGS
+    attr_reader :flags
+
+    # @return [Timestamps, nil] times for the start and/or end of the activity
+    attr_reader :timestamps
+
+    # @return [Secrets, nil] secrets for rich presence, joining, and spectating
+    attr_reader :secrets
+
+    # @return [Assets, nil] images for the presence and their texts
+    attr_reader :assets
+
+    # @return [Party, nil] information about the player's current party
+    attr_reader :party
+
+    # @return [Emoji, nil] emoji data for custom statuses
+    attr_reader :emoji
+
+    # @return [Time] the time when the activity was added to the user's session
+    attr_reader :created_at
+
+    # Type indicating the activity is for a game
+    GAME = 0
+    # Type indicating the activity is a stream
+    STREAMING = 1
+    # Type indicating the activity is for music
+    LISTENING = 2
+    # This type is currently unused in the client but can be reported by bots
+    WATCHING = 3
+    # Type indicating the activity is a custom status
+    CUSTOM = 4
+
+    # @!visibility private
+    def initialize(data, bot)
+      @name = data['name']
+      @type = data['type']
+      @url = data['url']
+      @application_id = data['application_id']
+      @details = data['details']
+      @state = data['state']
+      @instance = data['instance']
+      @flags = data['flags'] || 0
+      @created_at = Time.at(data['created_at'].to_i)
+
+      @timestamps = Timestamps.new(data['timestamps']) if data['timestamps']
+      @secrets = Secret.new(data['secrets']) if data['secrets']
+      @assets = Assets.new(data['assets'], @application_id) if data['assets']
+      @party = Party.new(data['party']) if data['party']
+      @emoji = Emoji.new(data['emoji'], bot, nil) if data['emoji']
+    end
+
+    # @return [true, false] Whether or not the `join` flag is set for this activity
+    def join?
+      flag_set? :join
+    end
+
+    # @return [true, false] Whether or not the `spectate` flag is set for this activity
+    def spectate?
+      flag_set? :spectate
+    end
+
+    # @return [true, false] Whether or not the `join_request` flag is set for this activity
+    def join_request?
+      flag_set? :join_request
+    end
+
+    # @return [true, false] Whether or not the `sync` flag is set for this activity
+    def sync?
+      flag_set? :sync
+    end
+
+    # @return [true, false] Whether or not the `play` flag is set for this activity
+    def play?
+      flag_set? :play
+    end
+
+    # @return [true, false] Whether or not the `instance` flag is set for this activity
+    def instance?
+      @instance || flag_set?(:instance)
+    end
+
+    # @!visibility private
+    def flag_set?(sym)
+      !(@flags & FLAGS[sym]).zero?
+    end
+
+    # Timestamps for the start and end of instanced activities
+    class Timestamps
+      # @return [Time, nil]
+      attr_reader :start
+
+      # @return [Time, nil]
+      attr_reader :end
+
+      # @!visibility private
+      def initialize(data)
+        @start = Time.at(data['start'] / 1000) if data['start']
+        @end = Time.at(data['end'] / 1000) if data['end']
+      end
+    end
+
+    # Contains secrets used for rich presence
+    class Secrets
+      # @return [String, nil] secret for joining a party
+      attr_reader :join
+
+      # @return [String, nil] secret for spectating
+      attr_reader :spectate
+
+      # @return [String, nil] secret for a specific instanced match
+      attr_reader :match
+
+      # @!visibility private
+      def initialize(data)
+        @join = data['join']
+        @spectate = data['spectate']
+        @match = data['match']
+      end
+    end
+
+    # Assets for rich presence images and hover text
+    class Assets
+      # @return [String, nil] the asset ID for the large image of this activity
+      attr_reader :large_image_id
+
+      # @return [String, nil] text displayed when hovering over the large iamge
+      attr_reader :large_text
+
+      # @return [String, nil] the asset ID for the small image of this activity
+      attr_reader :small_image_id
+
+      # @return [String, nil]
+      attr_reader :small_text
+
+      # @return [String, nil] the application ID for these assets.
+      attr_reader :application_id
+
+      # @!visibility private
+      def initialize(data, application_id)
+        @application_id = application_id
+        @large_image_id = data['large_image']
+        @large_text = data['large_text']
+        @small_image_id = data['small_image']
+        @small_text = data['small_text']
+      end
+
+      # Utility function to get an Asset's large image URL.
+      # @param format [String, nil] If `nil`, the URL will default to `webp`. You can otherwise specify one of `webp`, `jpg`, or `png`.
+      # @return [String] the URL to the large image asset.
+      def large_image_url(format = 'webp')
+        API.asset_url(@application_id, @large_image_id, format)
+      end
+
+      # Utility function to get an Asset's large image URL.
+      # @param format [String, nil] If `nil`, the URL will default to `webp`. You can otherwise specify one of `webp`, `jpg`, or `png`.
+      # @return [String] the URL to the small image asset.
+      def small_image_url(format = 'webp')
+        API.asset_url(@application_id, @small_image_id, format)
+      end
+    end
+
+    # Contains information about an activity's party
+    class Party
+      # @return [String, nil]
+      attr_reader :id
+
+      # @return [Integer, nil]
+      attr_reader :current_size
+
+      # @return [Integer, nil]
+      attr_reader :max_size
+
+      # @!visibility private
+      def initialize(data)
+        @id = data['id']
+        @current_size, @max_size = data['size']
+      end
+    end
+  end
+
+  # A collection of the user's activities.
+  class ActivitySet
+    include Enumerable
+
+    # @!visibility private
+    def initialize(activities = [])
+      @activities = activities
+    end
+
+    # @!visibility private
+    # Implement each for Enumerable
+    def each(&block)
+      @activities.each(&block)
+    end
+
+    # @return [Array<Activity>] all activities
+    def to_a
+      @activities
+    end
+
+    # @return [Array<Activity>] all activities of type {Activity::GAME}
+    def games
+      @activities.select { |act| act.type == Activity::GAME }
+    end
+
+    # @return [Array<Activity>] all activities of type {Activity::STREAMING}
+    def streaming
+      @activities.select { |act| act.type == Activity::STREAMING }
+    end
+
+    # @return [Array<Activity>] all activities of type {Activity::LISTENING}
+    def listening
+      @activities.select { |act| act.type == Activity::LISTENING }
+    end
+
+    # @return [Array<Activity>] all activities of type {Activity::WATCHING}
+    def watching
+      @activities.select { |act| act.type == Activity::WATCHING }
+    end
+
+    # @return [Array<Activity>] all activities of type {Activity::CUSTOM}
+    def custom_status
+      @activities.select { |act| act.type == Activity::CUSTOM }
+    end
+  end
+end

data/lib/discordrb/data/application.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # OAuth Application information
+  class Application
+    include IDObject
+
+    # @return [String] the application name
+    attr_reader :name
+
+    # @return [String] the application description
+    attr_reader :description
+
+    # @return [Array<String>] the application's origins permitted to use RPC
+    attr_reader :rpc_origins
+
+    # @return [Integer]
+    attr_reader :flags
+
+    # Gets the user object of the owner. May be limited to username, discriminator,
+    # ID, and avatar if the bot cannot reach the owner.
+    # @return [User] the user object of the owner
+    attr_reader :owner
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @name = data['name']
+      @id = data['id'].to_i
+      @description = data['description']
+      @icon_id = data['icon']
+      @rpc_origins = data['rpc_origins']
+      @flags = data['flags']
+      @owner = @bot.ensure_user(data['owner'])
+    end
+
+    # Utility function to get a application's icon URL.
+    # @return [String, nil] the URL of the icon image (nil if no image is set).
+    def icon_url
+      return nil if @icon_id.nil?
+
+      API.app_icon_url(@id, @icon_id)
+    end
+
+    # The inspect method is overwritten to give more useful output
+    def inspect
+      "<Application name=#{@name} id=#{@id}>"
+    end
+  end
+end

data/lib/discordrb/data/attachment.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # An attachment to a message
+  class Attachment
+    include IDObject
+
+    # @return [Message] the message this attachment belongs to.
+    attr_reader :message
+
+    # @return [String] the CDN URL this attachment can be downloaded at.
+    attr_reader :url
+
+    # @return [String] the attachment's proxy URL - I'm not sure what exactly this does, but I think it has something to
+    #   do with CDNs.
+    attr_reader :proxy_url
+
+    # @return [String] the attachment's filename.
+    attr_reader :filename
+
+    # @return [Integer] the attachment's file size in bytes.
+    attr_reader :size
+
+    # @return [Integer, nil] the width of an image file, in pixels, or `nil` if the file is not an image.
+    attr_reader :width
+
+    # @return [Integer, nil] the height of an image file, in pixels, or `nil` if the file is not an image.
+    attr_reader :height
+
+    # @!visibility private
+    def initialize(data, message, bot)
+      @bot = bot
+      @message = message
+
+      @id = data['id'].to_i
+      @url = data['url']
+      @proxy_url = data['proxy_url']
+      @filename = data['filename']
+
+      @size = data['size']
+
+      @width = data['width']
+      @height = data['height']
+    end
+
+    # @return [true, false] whether this file is an image file.
+    def image?
+      !(@width.nil? || @height.nil?)
+    end
+
+    # @return [true, false] whether this file is tagged as a spoiler.
+    def spoiler?
+      @filename.start_with? 'SPOILER_'
+    end
+  end
+end

data/lib/discordrb/data/audit_logs.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # A server's audit logs
+  class AuditLogs
+    # The numbers associated with the type of action.
+    ACTIONS = {
+      1 => :server_update,
+      10 => :channel_create,
+      11 => :channel_update,
+      12 => :channel_delete,
+      13 => :channel_overwrite_create,
+      14 => :channel_overwrite_update,
+      15 => :channel_overwrite_delete,
+      20 => :member_kick,
+      21 => :member_prune,
+      22 => :member_ban_add,
+      23 => :member_ban_remove,
+      24 => :member_update,
+      25 => :member_role_update,
+      26 => :member_move,
+      27 => :member_disconnect,
+      28 => :bot_add,
+      30 => :role_create,
+      31 => :role_update,
+      32 => :role_delete,
+      40 => :invite_create,
+      41 => :invite_update,
+      42 => :invite_delete,
+      50 => :webhook_create,
+      51 => :webhook_update,
+      52 => :webhook_delete,
+      60 => :emoji_create,
+      61 => :emoji_update,
+      62 => :emoji_delete,
+      # 70
+      # 71
+      72 => :message_delete,
+      73 => :message_bulk_delete,
+      74 => :message_pin,
+      75 => :message_unpin,
+      80 => :integration_create,
+      81 => :integration_update,
+      82 => :integration_delete
+    }.freeze
+
+    # @!visibility private
+    CREATE_ACTIONS = %i[
+      channel_create channel_overwrite_create member_ban_add role_create
+      invite_create webhook_create emoji_create integration_create
+    ].freeze
+
+    # @!visibility private
+    DELETE_ACTIONS = %i[
+      channel_delete channel_overwrite_delete member_kick member_prune
+      member_ban_remove role_delete invite_delete webhook_delete
+      emoji_delete message_delete message_bulk_delete integration_delete
+    ].freeze
+
+    # @!visibility private
+    UPDATE_ACTIONS = %i[
+      server_update channel_update channel_overwrite_update member_update
+      member_role_update role_update invite_update webhook_update
+      emoji_update integration_update
+    ].freeze
+
+    # @return [Hash<String => User>] the users included in the audit logs.
+    attr_reader :users
+
+    # @return [Hash<String => Webhook>] the webhooks included in the audit logs.
+    attr_reader :webhooks
+
+    # @return [Array<Entry>] the entries listed in the audit logs.
+    attr_reader :entries
+
+    # @!visibility private
+    def initialize(server, bot, data)
+      @bot = bot
+      @server = server
+      @users = {}
+      @webhooks = {}
+      @entries = data['audit_log_entries'].map { |entry| Entry.new(self, @server, @bot, entry) }
+
+      process_users(data['users'])
+      process_webhooks(data['webhooks'])
+    end
+
+    # An entry in a server's audit logs.
+    class Entry
+      include IDObject
+
+      # @return [Symbol] the action that was performed.
+      attr_reader :action
+
+      # @return [Symbol] the type action that was performed. (:create, :delete, :update, :unknown)
+      attr_reader :action_type
+
+      # @return [Symbol] the type of target being performed on. (:server, :channel, :user, :role, :invite, :webhook, :emoji, :unknown)
+      attr_reader :target_type
+
+      # @return [Integer, nil] the amount of messages deleted. Only present if the action is `:message_delete`.
+      attr_reader :count
+      alias_method :amount, :count
+
+      # @return [Integer, nil] the amount of days the members were inactive for. Only present if the action is `:member_prune`.
+      attr_reader :days
+
+      # @return [Integer, nil] the amount of members removed. Only present if the action is `:member_prune`.
+      attr_reader :members_removed
+
+      # @return [String, nil] the reason for this action occurring.
+      attr_reader :reason
+
+      # @return [Hash<String => Change>, RoleChange, nil] the changes from this log, listing the key as the key changed. Will be a RoleChange object if the action is `:member_role_update`. Will be nil if the action is either `:message_delete` or `:member_prune`.
+      attr_reader :changes
+
+      # @!visibility private
+      def initialize(logs, server, bot, data)
+        @bot = bot
+        @id = data['id'].resolve_id
+        @logs = logs
+        @server = server
+        @data = data
+        @action = ACTIONS[data['action_type']]
+        @reason = data['reason']
+        @action_type = AuditLogs.action_type_for(data['action_type'])
+        @target_type = AuditLogs.target_type_for(data['action_type'])
+
+        # Sets the 'changes' variable to a empty hash if there are no special actions.
+        @changes = {} unless @action == :message_delete || @action == :member_prune || @action == :member_role_update
+
+        # Sets the 'changes' variable to a RoleChange class if there's a role update.
+        @changes = RoleChange.new(data['changes'][0], @server) if @action == :member_role_update
+
+        process_changes(data['changes']) unless @action == :member_role_update
+        return unless data.include?('options')
+
+        # Checks and sets variables for special action options.
+        @count = data['options']['count'].to_i unless data['options']['count'].nil?
+        @channel_id = data['options']['channel'].to_i unless data['options']['channel'].nil?
+        @days = data['options']['delete_member_days'].to_i unless data['options']['delete_member_days'].nil?
+        @members_removed = data['options']['members_removed'].to_i unless data['options']['members_removed'].nil?
+      end
+
+      # @return [Server, Channel, Member, User, Role, Invite, Webhook, Emoji, nil] the target being performed on.
+      def target
+        @target ||= process_target(@data['target_id'], @target_type)
+      end
+
+      # @return [Member, User] the user that authored this action. Can be a User object if the user no longer exists in the server.
+      def user
+        @user ||= @server.member(@data['user_id'].to_i) || @bot.user(@data['user_id'].to_i) || @logs.user(@data['user_id'].to_i)
+      end
+      alias_method :author, :user
+
+      # @return [Channel, nil] the amount of messages deleted. Won't be nil if the action is `:message_delete`.
+      def channel
+        return nil unless @channel_id
+
+        @channel ||= @bot.channel(@channel_id, @server, bot, self)
+      end
+
+      # @!visibility private
+      def process_target(id, type)
+        id = id.resolve_id unless id.nil?
+        case type
+        when :server then @server # Since it won't be anything else
+        when :channel then @bot.channel(id, @server)
+        when :user, :message then @server.member(id) || @bot.user(id) || @logs.user(id)
+        when :role then @server.role(id)
+        when :invite then @bot.invite(@data['changes'].find { |change| change['key'] == 'code' }.values.delete_if { |v| v == 'code' }.first)
+        when :webhook then @server.webhooks.find { |webhook| webhook.id == id } || @logs.webhook(id)
+        when :emoji then @server.emoji[id]
+        when :integration then @server.integrations.find { |integration| integration.id == id }
+        end
+      end
+
+      # The inspect method is overwritten to give more useful output
+      def inspect
+        "<AuditLogs::Entry id=#{@id} action=#{@action} reason=#{@reason} action_type=#{@action_type} target_type=#{@target_type} count=#{@count} days=#{@days} members_removed=#{@members_removed}>"
+      end
+
+      # Process action changes
+      # @note For internal use only
+      # @!visibility private
+      def process_changes(changes)
+        return unless changes
+
+        changes.each do |element|
+          change = Change.new(element, @server, @bot, self)
+          @changes[change.key] = change
+        end
+      end
+    end
+
+    # A change in a audit log entry.
+    class Change
+      # @return [String] the key that was changed.
+      # @note You should check with the Discord API Documentation on what key gives out what value.
+      attr_reader :key
+
+      # @return [String, Integer, true, false, Permissions, Overwrite, nil] the value that was changed from.
+      attr_reader :old
+      alias_method :old_value, :old
+
+      # @return [String, Integer, true, false, Permissions, Overwrite, nil] the value that was changed to.
+      attr_reader :new
+      alias_method :new_value, :new
+
+      # @!visibility private
+      def initialize(data, server, bot, logs)
+        @key = data['key']
+        @old = data['old_value']
+        @new = data['new_value']
+        @server = server
+        @bot = bot
+        @logs = logs
+
+        @old = Permissions.new(@old) if @old && @key == 'permissions'
+        @new = Permissions.new(@new) if @new && @key == 'permissions'
+
+        @old = @old.map { |o| Overwrite.new(o['id'], type: o['type'].to_sym, allow: o['allow'], deny: o['deny']) } if @old && @key == 'permission_overwrites'
+        @new = @new.map { |o| Overwrite.new(o['id'], type: o['type'].to_sym, allow: o['allow'], deny: o['deny']) } if @new && @key == 'permission_overwrites'
+      end
+
+      # @return [Channel, nil] the channel that was previously used in the server widget. Only present if the key for this change is `widget_channel_id`.
+      def old_widget_channel
+        @bot.channel(@old, @server) if @old && @key == 'widget_channel_id'
+      end
+
+      # @return [Channel, nil] the channel that is used in the server widget prior to this change. Only present if the key for this change is `widget_channel_id`.
+      def new_widget_channel
+        @bot.channel(@new, @server) if @new && @key == 'widget_channel_id'
+      end
+
+      # @return [Channel, nil] the channel that was previously used in the server as an AFK channel. Only present if the key for this change is `afk_channel_id`.
+      def old_afk_channel
+        @bot.channel(@old, @server) if @old && @key == 'afk_channel_id'
+      end
+
+      # @return [Channel, nil] the channel that is used in the server as an AFK channel prior to this change. Only present if the key for this change is `afk_channel_id`.
+      def new_afk_channel
+        @bot.channel(@new, @server) if @new && @key == 'afk_channel_id'
+      end
+
+      # @return [Member, User, nil] the member that used to be the owner of the server. Only present if the for key for this change is `owner_id`.
+      def old_owner
+        @server.member(@old) || @bot.user(@old) || @logs.user(@old) if @old && @key == 'owner_id'
+      end
+
+      # @return [Member, User, nil] the member that is now the owner of the server prior to this change. Only present if the key for this change is `owner_id`.
+      def new_owner
+        @server.member(@new) || @bot.user(@new) || @logs.user(@new) if @new && @key == 'owner_id'
+      end
+    end
+
+    # A change that includes roles.
+    class RoleChange
+      # @return [Symbol] what type of change this is: (:add, :remove)
+      attr_reader :type
+
+      # @!visibility private
+      def initialize(data, server)
+        @type = data['key'].delete('$').to_sym
+        @role_id = data['new_value'][0]['id'].to_i
+        @server = server
+      end
+
+      # @return [Role] the role being used.
+      def role
+        @role ||= @server.role(@role_id)
+      end
+    end
+
+    # @return [Entry] the latest entry in the audit logs.
+    def latest
+      @entries.first
+    end
+    alias_method :first, :latest
+
+    # Gets a user in the audit logs data based on user ID
+    # @note This only uses data given by the audit logs request
+    # @param id [String, Integer] The user ID to look for
+    def user(id)
+      @users[id.resolve_id]
+    end
+
+    # Gets a webhook in the audit logs data based on webhook ID
+    # @note This only uses data given by the audit logs request
+    # @param id [String, Integer] The webhook ID to look for
+    def webhook(id)
+      @webhooks[id.resolve_id]
+    end
+
+    # Process user objects given by the request
+    # @note For internal use only
+    # @!visibility private
+    def process_users(users)
+      users.each do |element|
+        user = User.new(element, @bot)
+        @users[user.id] = user
+      end
+    end
+
+    # Process webhook objects given by the request
+    # @note For internal use only
+    # @!visibility private
+    def process_webhooks(webhooks)
+      webhooks.each do |element|
+        webhook = Webhook.new(element, @bot)
+        @webhooks[webhook.id] = webhook
+      end
+    end
+
+    # Find the type of target by it's action number
+    # @note For internal use only
+    # @!visibility private
+    def self.target_type_for(action)
+      case action
+      when 1..9 then :server
+      when 10..19 then :channel
+      when 20..29 then :user
+      when 30..39 then :role
+      when 40..49 then :invite
+      when 50..59 then :webhook
+      when 60..69 then :emoji
+      when 70..79 then :message
+      when 80..89 then :integration
+      else :unknown
+      end
+    end
+
+    # Find the type of action by its action number
+    # @note For internal use only
+    # @!visibility private
+    def self.action_type_for(action)
+      action = ACTIONS[action]
+      return :create if CREATE_ACTIONS.include?(action)
+      return :delete if DELETE_ACTIONS.include?(action)
+      return :update if UPDATE_ACTIONS.include?(action)
+
+      :unknown
+    end
+  end
+end