discorb 0.16.0 → 0.18.0

data/lib/discorb/application.rb

@@ -29,6 +29,7 @@ module Discorb
     alias bot_require_code_grant? bot_require_code_grant
     # @return [Discorb::Application::Flag] The application's flags.
     attr_reader :flags
+
     #
     # Initializes a new instance of the Application class.
     # @private

data/lib/discorb/asset.rb

@@ -51,7 +51,7 @@ module Discorb
       case @target
       when User, Member, Webhook
         "avatars"
-      when Guild, IncomingWebhook::Guild
+      when Guild, Webhook::FollowerWebhook::Guild
         "icons"
       when Application, Integration::Application
         "app-icons"
@@ -65,7 +65,6 @@ module Discorb
   # Represents a default avatar.
   #
   class DefaultAvatar < DiscordModel
-
     # @!attribute [r] animated?
     #   @return [false] For compatibility with {Asset}, always `false`.
 

data/lib/discorb/attachment.rb

@@ -70,7 +70,7 @@ module Discorb
     def initialize_hash(data)
       @id = Snowflake.new(data[:id])
       @filename = data[:filename]
-      @content_type = data[:content_type]
+      @content_type = data[:content_type] || "application/octet-stream"
       @size = data[:size]
       @url = data[:url]
       @proxy_url = data[:proxy_url]

data/lib/discorb/audit_logs.rb

@@ -21,9 +21,11 @@ module Discorb
     def initialize(client, data, guild)
       @client = client
       @guild = guild
-      @webhooks = data[:webhooks].map { |webhook| Webhook.new([@client, webhook]) }
+      @webhooks = data[:webhooks].map { |webhook| Webhook.from_data(@client, webhook) }
       @users = data[:users].map { |user| client.users[user[:id]] || User.new(@client, user) }
-      @threads = data[:threads].map { |thread| client.channels[thread[:id]] || Channel.make_channel(@client, thread, no_cache: true) }
+      @threads = data[:threads].map do |thread|
+        client.channels[thread[:id]] || Channel.make_channel(@client, thread, no_cache: true)
+      end
       @entries = data[:audit_log_entries].map { |entry| AuditLog::Entry.new(@client, entry, guild.id) }
     end
 
@@ -103,10 +105,12 @@ module Discorb
       # * `:thread_create`
       # * `:thread_update`
       # * `:thread_delete`
+      # * `:application_command_permission_update``
       attr_reader :type
       # @return [Discorb::AuditLog::Entry::Changes] The changes in this entry.
       attr_reader :changes
-      # @return [Discorb::Channel, Discorb::Role, Discorb::Member, Discorb::Guild, Discorb::Message] The target of the entry.
+      # @return [Discorb::Channel, Discorb::Role, Discorb::Member, Discorb::Guild, Discorb::Message, Discorb::Snowflake]
+      #   The target of the entry.
       attr_reader :target
       # @return [Hash{Symbol => Object}] The optional data for this entry.
       # @note You can use dot notation to access the data.
@@ -167,6 +171,11 @@ module Discorb
         110 => :thread_create,
         111 => :thread_update,
         112 => :thread_delete,
+        121 => :application_command_permission_update,
+        140 => :automod_rule_create,
+        141 => :automod_rule_update,
+        142 => :automod_rule_delete,
+        143 => :automod_block_message,
       }.freeze
 
       #
@@ -192,16 +201,16 @@ module Discorb
         @id = Snowflake.new(data[:id])
         @user_id = Snowflake.new(data[:user_id])
         @target_id = Snowflake.new(data[:target_id])
-        @type = EVENTS[data[:action_type]]
-        @target = self.class.converts[@type.to_s.split("_")[0].to_sym]&.call(client, @target_id, @gui)
+        @type = EVENTS[data[:action_type]] || :unknown
+        @target = CONVERTERS[@type.to_s.split("_")[0].to_sym]&.call(client, @target_id, @gui)
         @target ||= Snowflake.new(data[:target_id])
         @changes = data[:changes] && Changes.new(data[:changes])
         @reason = data[:reason]
         data[:options]&.each do |option, value|
           define_singleton_method(option) { value }
-          if option.end_with?("_id")
+          if option.end_with?("_id") && CONVERTERS.key?(option.to_s.split("_")[0].to_sym)
             define_singleton_method(option.to_s.sub("_id", "")) do
-              self.class.converts[option.to_s.split("_")[0].to_sym]&.call(client, value, @guild_id)
+              CONVERTERS[option.to_s.split("_")[0].to_sym]&.call(client, value, @guild_id)
             end
           end
         end
@@ -304,11 +313,11 @@ module Discorb
             when "permissions"
               ->(v) { Discorb::Permission.new(v.to_i) }
             when "status"
-              ->(v) { Discorb::ScheduledEvent.status[v] }
+              ->(v) { Discorb::ScheduledEvent::STATUS[v] }
             when "entity_type"
-              ->(v) { Discorb::ScheduledEvent.entity_type[v] }
+              ->(v) { Discorb::ScheduledEvent::ENTITY_TYPE[v] }
             when "privacy_level"
-              ->(v) { Discorb::StageInstance.privacy_level[v] || Discorb::ScheduledEvent.privacy_level[v] }
+              ->(v) { Discorb::StageInstance::PRIVACY_LEVEL[v] || Discorb::ScheduledEvent::PRIVACY_LEVEL[v] }
             else
               ->(v) { v }
             end

data/lib/discorb/automod.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a rule of auto moderation.
+  #
+  class AutoModRule < DiscordModel
+    # @return [Hash{Integer => Symbol}] The mapping of trigger types.
+    # @private
+    TRIGGER_TYPES = {
+      1 => :keyword,
+      2 => :harmful_link,
+      3 => :spam,
+      4 => :keyword_preset,
+    }.freeze
+    # @return [Hash{Integer => Symbol}] The mapping of preset types.
+    # @private
+    PRESET_TYPES = {
+      1 => :profanity,
+      2 => :sexual_content,
+      3 => :slurs,
+    }.freeze
+    # @return [Hash{Integer => Symbol}] The mapping of event types.
+    # @private
+    EVENT_TYPES = {
+      1 => :message_send,
+    }.freeze
+
+    # @return [Discorb::Snowflake] The ID of the rule.
+    attr_reader :id
+    # @return [String] The name of the rule.
+    attr_reader :name
+    # @return [Boolean] Whether the rule is enabled.
+    attr_reader :enabled
+    alias enabled? enabled
+    # @return [Array<Discorb::AutoModRule::Action>] The actions of the rule.
+    attr_reader :actions
+    # @return [Array<String>] The keywords that the rule is triggered by.
+    # @note This is only available if the trigger type is `:keyword`.
+    attr_reader :keyword_filter
+
+    #
+    # Initialize a new auto mod.
+    # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Hash] data The auto mod data.
+    #
+    def initialize(client, data)
+      @client = client
+      _set_data(data)
+    end
+
+    # @!attribute [r]
+    #   @return [Symbol] Returns the type of the preset.
+    #   @note This is only available if the trigger type is `:keyword_preset`.
+    def preset_type
+      PRESET_TYPES[@presets_raw]
+    end
+
+    # @!attribute [r]
+    #   @return [Symbol] Returns the type of the trigger.
+    def trigger_type
+      TRIGGER_TYPES[@trigger_type_raw]
+    end
+
+    # @!attribute [r]
+    #   @return [Symbol] Returns the type of the event.
+    def event_type
+      EVENT_TYPES[@event_type_raw]
+    end
+
+    # @!attribute [r]
+    #   @macro client_cache
+    #   @return [Discorb::Member] The member who created the rule.
+    def creator
+      guild.members[@creator_id]
+    end
+
+    # @!attribute [r]
+    #   @return [Discorb::Guild] The guild that the rule is in.
+    def guild
+      @client.guilds[@guild_id]
+    end
+
+    # @!attribute [r]
+    #   @return [Array<Discorb::Role>] The roles that the rule is exempt from.
+    def exempt_roles
+      @exempt_roles_id.map { |id| guild.roles[id] }
+    end
+
+    # @!attribute [r]
+    #   @return [Array<Discorb::Channel>] The channels that the rule is exempt from.
+    def exempt_channels
+      @exempt_channels_id.map { |id| guild.channels[id] }
+    end
+
+    #
+    # Edit the rule.
+    # @async
+    # @edit
+    #
+    # @param [String] name The name of the rule.
+    # @param [Symbol] event_type The event type of the rule. See {Discorb::AutoModRule::EVENT_TYPES}.
+    # @param [Array<Discorb::AutoModRule::Action>] actions The actions of the rule.
+    # @param [Boolean] enabled Whether the rule is enabled or not.
+    # @param [Array<Discorb::Role>] exempt_roles The roles that are exempt from the rule.
+    # @param [Array<Discorb::Channel>] exempt_channels The channels that are exempt from the rule.
+    # @param [Array<String>] keyword_filter The keywords to filter.
+    # @param [Symbol] presets The preset of the rule. See {Discorb::AutoModRule::PRESET_TYPES}.
+    # @param [String] reason The reason for creating the rule.
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def edit(
+      name: Discorb::Unset,
+      event_type: Discorb::Unset,
+      actions: Discorb::Unset,
+      enabled: Discorb::Unset,
+      exempt_roles: Discorb::Unset,
+      exempt_channels: Discorb::Unset,
+      keyword_filter: Discorb::Unset,
+      presets: Discorb::Unset,
+      reason: nil
+    )
+      # @type var payload: Hash[Symbol, untyped]
+      payload = {
+        metadata: {},
+      }
+      payload[:name] = name unless name == Discorb::Unset
+      payload[:event_type] = EVENT_TYPES.key(event_type) unless event_type == Discorb::Unset
+      payload[:actions] = actions unless actions == Discorb::Unset
+      payload[:enabled] = enabled unless enabled == Discorb::Unset
+      payload[:exempt_roles] = exempt_roles.map(&:id) unless exempt_roles == Discorb::Unset
+      payload[:exempt_channels] = exempt_channels.map(&:id) unless exempt_channels == Discorb::Unset
+      payload[:metadata][:keyword_filter] = keyword_filter unless keyword_filter == Discorb::Unset
+      payload[:metadata][:presets] = PRESET_TYPES.key(presets) unless presets == Discorb::Unset
+
+      @client.http.request(
+        Route.new(
+          "/guilds/#{@guild_id}/automod/rules/#{@id}",
+          "//guilds/:guild_id/automod/rules/:id",
+          :patch
+        ),
+        payload,
+        audit_log_reason: reason,
+      )
+    end
+
+    #
+    # Delete the rule.
+    #
+    # @param [String] reason The reason for deleting the rule.
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def delete!(reason: nil)
+      Async do
+        @client.http.request(
+          Route.new(
+            "/guilds/#{@guild_id}/automod/rules/#{@id}",
+            "//guilds/:guild_id/automod/rules/:id",
+            :delete
+          ),
+          audit_log_reason: reason,
+        )
+      end
+    end
+
+    # @private
+    def _set_data(data)
+      @id = Snowflake.new(data[:id])
+      @guild_id = data[:guild_id]
+      @name = data[:name]
+      @creator_id = data[:creator_id]
+      @trigger_type_raw = data[:trigger_type]
+      @event_type_raw = data[:event_type]
+      @actions = data[:actions].map { |action| Action.from_hash(@client, action) }
+      case trigger_type
+      when :keyword
+        @keyword_filter = data[:trigger_metadata][:keyword_filter]
+      when :presets
+        @presets_raw = data[:trigger_metadata][:presets]
+      end
+      @enabled = data[:enabled]
+      @exempt_roles_id = data[:exempt_roles]
+      @exempt_channels_id = data[:exempt_channels]
+    end
+
+    #
+    # Represents the action of auto moderation.
+    #
+    class Action < DiscordModel
+      # @return [Hash{Integer => Symbol}] The mapping of action types.
+      # @private
+      ACTION_TYPES = {
+        1 => :block_message,
+        2 => :send_alert_message,
+        3 => :timeout,
+      }.freeze
+
+      # @return [Symbol] Returns the type of the action.
+      attr_reader :type
+      # @return [Integer] The duration of the timeout.
+      # @note This is only available if the action type is `:timeout`.
+      attr_reader :duration_seconds
+
+      #
+      # Initialize a new action.
+      #
+      # @param [Symbol] type The type of the action.
+      # @param [Integer] duration_seconds The duration of the timeout.
+      #   This is only available if the action type is `:timeout`.
+      # @param [Discorb::Channel] channel The channel that the alert message is sent to.
+      #   This is only available if the action type is `:send_alert_message`.
+      #
+      def initialize(type, duration_seconds: nil, channel: nil)
+        @type = type
+        @duration_seconds = duration_seconds
+        @channel = channel
+      end
+
+      #
+      # Convert the action to hash.
+      #
+      # @return [Hash] The action hash.
+      #
+      def to_hash
+        {
+          type: @type,
+          metadata: {
+            channel_id: @channel&.id,
+            duration_seconds: @duration_seconds,
+          },
+        }
+      end
+
+      #
+      # Initialize a new action from hash.
+      # @private
+      #
+      # @param [Discorb::Client] client The client.
+      # @param [Hash] data The action data.
+      #
+      def initialize_hash(client, data)
+        @client = client
+        _set_data(data)
+      end
+
+      # @!attribute [r]
+      #   @return [Discorb::Channel] The channel that the alert message is sent to.
+      #   @note This is only available if the action type is `:send_alert_message`.
+      def channel
+        @client.channels[@channel_id]
+      end
+
+      # @private
+      def _set_data(data)
+        @type = ACTION_TYPES[data[:type]]
+        @channel_id = data[:metadata][:channel_id]
+        @duration_seconds = data[:metadata][:duration_seconds]
+      end
+
+      def self.from_hash(client, data)
+        allocate.tap { |action| action.initialize_hash(client, data) }
+      end
+    end
+  end
+end

data/lib/discorb/channel/base.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a channel of Discord.
+  # @abstract
+  #
+  class Channel < DiscordModel
+    # @return [Discorb::Snowflake] The ID of the channel.
+    attr_reader :id
+    # @return [String] The name of the channel.
+    attr_reader :name
+
+    # @!attribute [r] type
+    #   @return [Integer] The type of the channel as integer.
+
+    @channel_type = nil
+    @subclasses = []
+
+    #
+    # Initializes a new instance of the Channel class.
+    # @private
+    #
+    def initialize(client, data, no_cache: false)
+      @client = client
+      @data = {}
+      @no_cache = no_cache
+      _set_data(data)
+    end
+
+    #
+    # Checks if the channel is other channel.
+    #
+    # @param [Discorb::Channel] other The channel to check.
+    #
+    # @return [Boolean] True if the channel is other channel.
+    #
+    def ==(other)
+      return false unless other.respond_to?(:id)
+
+      @id == other.id
+    end
+
+    def inspect
+      "#<#{self.class} \"##{@name}\" id=#{@id}>"
+    end
+
+    #
+    # Returns the descendants of the Channel class.
+    # @private
+    #
+    def self.descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+
+    #
+    # Creates a new instance of the Channel class or instance of its descendants.
+    # @private
+    #
+    # @param [Discorb::Client] client The client that instantiated the object.
+    # @param [Hash] data The data of the object.
+    # @param [Boolean] no_cache Whether to disable cache the object.
+    #
+    def self.make_channel(client, data, no_cache: false)
+      descendants.each do |klass|
+        if !klass.channel_type.nil? && klass.channel_type == data[:type]
+          return klass.new(client, data,
+                           no_cache: no_cache)
+        end
+      end
+      client.logger.warn("Unknown channel type #{data[:type]}, initialized GuildChannel")
+      GuildChannel.new(client, data)
+    end
+
+    class << self
+      #
+      # @private
+      # @return [Integer] The type of the channel.
+      #
+      attr_reader :channel_type
+    end
+
+    def type
+      self.class.channel_type
+    end
+
+    #
+    # Returns the channel id to request.
+    # @private
+    #
+    # @return [Async::Task<Discorb::Snowflake>] A task that resolves to the channel id.
+    #
+    def channel_id
+      Async do
+        @id
+      end
+    end
+
+    private
+
+    def _set_data(data)
+      @id = Snowflake.new(data[:id])
+      @name = data[:name]
+      @client.channels[@id] = self if !@no_cache && !(data[:no_cache])
+      @data.update(data)
+    end
+  end
+end

data/lib/discorb/channel/category.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a category in a guild.
+  #
+  class CategoryChannel < GuildChannel
+    @channel_type = 4
+
+    include Discorb::ChannelContainer
+
+    def channels
+      @client.channels.values.filter { |channel| channel.parent == self }
+    end
+
+    def create_text_channel(*args, **kwargs)
+      guild.create_text_channel(*args, parent: self, **kwargs)
+    end
+
+    def create_voice_channel(*args, **kwargs)
+      guild.create_voice_channel(*args, parent: self, **kwargs)
+    end
+
+    def create_news_channel(*args, **kwargs)
+      guild.create_news_channel(*args, parent: self, **kwargs)
+    end
+
+    def create_stage_channel(*args, **kwargs)
+      guild.create_stage_channel(*args, parent: self, **kwargs)
+    end
+  end
+end

data/lib/discorb/channel/container.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Module for container of channels.
+  #
+  module ChannelContainer
+    #
+    # Returns text channels.
+    #
+    # @return [Array<Discorb::TextChannel>] The text channels.
+    #
+    def text_channels
+      channels.filter { |c| c.instance_of? TextChannel }
+    end
+
+    #
+    # Returns voice channels.
+    #
+    # @return [Array<Discorb::VoiceChannel>] The voice channels.
+    #
+    def voice_channels
+      channels.filter { |c| c.instance_of? VoiceChannel }
+    end
+
+    #
+    # Returns news channels.
+    #
+    # @return [Array<Discorb::NewsChannel>] The news channels.
+    #
+    def news_channels
+      channels.filter { |c| c.instance_of? NewsChannel }
+    end
+
+    #
+    # Returns stage channels.
+    #
+    # @return [Array<Discorb::StageChannel>] The stage channels.
+    #
+    def stage_channels
+      channels.filter { |c| c.instance_of? StageChannel }
+    end
+  end
+end

data/lib/discorb/channel/dm.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a DM channel.
+  #
+  class DMChannel < Channel
+    include Messageable
+
+    #
+    # Returns the channel id to request.
+    # @private
+    #
+    # @return [Async::Task<Discorb::Snowflake>] A task that resolves to the channel id.
+    #
+    def channel_id
+      Async do
+        @id
+      end
+    end
+
+    private
+
+    def _set_data(data)
+      @id = Snowflake.new(data)
+    end
+  end
+end