discorb 0.17.1 → 0.19.0

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/guild.rb

@@ -34,7 +34,7 @@ module Discorb
     # @return [-1, 0, 1] -1 if the channel is at lower than the other, 1 if the channel is at highter than the other.
     #
     def <=>(other)
-      return 0 unless other.respond_to?(:position)
+      return nil unless other.respond_to?(:position)
 
       @position <=> other.position
     end
@@ -89,7 +89,7 @@ module Discorb
     #
     # @return [Async::Task<self>] The deleted channel.
     #
-    def delete!(reason: nil)
+    def delete(reason: nil)
       Async do
         @client.http.request(Route.new(base_url.wait.to_s, "//webhooks/:webhook_id/:token", :delete), {},
                              audit_log_reason: reason).wait
@@ -98,8 +98,8 @@ module Discorb
       end
     end
 
-    alias close! delete!
-    alias destroy! delete!
+    alias close delete
+    alias destroy delete
 
     #
     # Moves the channel to another position.
@@ -114,6 +114,7 @@ module Discorb
     #
     def move(position, lock_permissions: false, parent: Discorb::Unset, reason: nil)
       Async do
+        # @type var payload: Hash[Symbol, untyped]
         payload = {
           position: position,
         }

data/lib/discorb/channel/stage.rb

@@ -120,7 +120,7 @@ module Discorb
     end
 
     def speakers
-      voice_states.filter { |state| !state.suppress? }.map(&:member)
+      voice_states.reject(&:suppress?).map(&:member)
     end
 
     def audiences

data/lib/discorb/channel/text.rb

@@ -22,15 +22,6 @@ module Discorb
 
     include Messageable
 
-    # @return [{Integer => Symbol}] The auto archive duration map.
-    # @private
-    DEFAULT_AUTO_ARCHIVE_DURATION = {
-      60 => :hour,
-      1440 => :day,
-      4320 => :three_days,
-      10080 => :week,
-    }.freeze
-
     @channel_type = 0
 
     # @!attribute [r] threads
@@ -131,7 +122,7 @@ module Discorb
       Async do
         _resp, data = @client.http.request(Route.new("/channels/#{@id}/webhooks", "//channels/:channel_id/webhooks",
                                                      :get)).wait
-        data.map { |webhook| Webhook.new([@client, webhook]) }
+        data.map { |webhook| Webhook.from_data(@client, webhook) }
       end
     end
 
@@ -144,9 +135,9 @@ module Discorb
     #
     # @return [Async::Task<void>] The task.
     #
-    def delete_messages!(*messages, force: false)
+    def delete_messages(*messages, force: false)
       Async do
-        messages = messages.first if messages.length == 1 && messages.first.is_a?(Array)
+        messages = messages.flatten
         unless force
           time = Time.now
           messages.delete_if do |message|
@@ -165,8 +156,8 @@ module Discorb
       end
     end
 
-    alias bulk_delete! delete_messages!
-    alias destroy_messages! delete_messages!
+    alias bulk_delete delete_messages
+    alias destroy_messages delete_messages
 
     #
     # Follow the existing announcement channel.
@@ -208,14 +199,13 @@ module Discorb
       reason: nil
     )
       auto_archive_duration ||= @default_auto_archive_duration
-      auto_archive_duration_value = DEFAULT_AUTO_ARCHIVE_DURATION.key(auto_archive_duration)
       Async do
         _resp, data = if message.nil?
             @client.http.request(
               Route.new("/channels/#{@id}/threads", "//channels/:channel_id/threads", :post),
               {
                 name: name,
-                auto_archive_duration: auto_archive_duration_value,
+                auto_archive_duration: auto_archive_duration,
                 type: public ? 11 : 10,
                 rate_limit_per_user: rate_limit_per_user || slowmode,
               },
@@ -227,7 +217,7 @@ module Discorb
                         "//channels/:channel_id/messages/:message_id/threads", :post),
               {
                 name: name,
-                auto_archive_duration: auto_archive_duration_value,
+                auto_archive_duration: auto_archive_duration,
               },
               audit_log_reason: reason,
             ).wait
@@ -271,33 +261,34 @@ module Discorb
     # @async
     #
     # @param [Integer] limit The limit of threads to fetch.
-    # @param [Time] before <description>
+    # @param [Time] before The time before which the threads are created.
     #
     # @return [Async::Task<Array<Discorb::ThreadChannel>>] The joined archived private threads in the channel.
     #
     def fetch_joined_archived_private_threads(limit: nil, before: nil)
       Async do
         if limit.nil?
-          before = 0
+          before = Time.now
           threads = []
           loop do
             _resp, data = @client.http.request(
               Route.new(
-                "/channels/#{@id}/users/@me/threads/archived/private?before=#{before}",
+                "/channels/#{@id}/users/@me/threads/archived/private?before=#{before.iso8601}",
                 "//channels/:channel_id/users/@me/threads/archived/private",
                 :get
               )
             ).wait
             threads += data[:threads].map { |thread| Channel.make_channel(@client, thread) }
-            before = data[:threads][-1][:id]
 
             break unless data[:has_more]
+
+            before = Snowflake.new(data[:threads][-1][:id]).timestamp
           end
           threads
         else
           _resp, data = @client.http.request(
             Route.new(
-              "/channels/#{@id}/users/@me/threads/archived/private?limit=#{limit}&before=#{before}",
+              "/channels/#{@id}/users/@me/threads/archived/private?limit=#{limit}&before=#{before.iso8601}",
               "//channels/:channel_id/users/@me/threads/archived/private",
               :get
             )
@@ -315,7 +306,7 @@ module Discorb
       @last_message_id = data[:last_message_id]
       @rate_limit_per_user = data[:rate_limit_per_user]
       @last_pin_timestamp = data[:last_pin_timestamp] && Time.iso8601(data[:last_pin_timestamp])
-      @default_auto_archive_duration = DEFAULT_AUTO_ARCHIVE_DURATION[data[:default_auto_archive_duration]]
+      @default_auto_archive_duration = data[:default_auto_archive_duration]
       super
     end
   end

data/lib/discorb/channel/thread.rb

@@ -112,7 +112,7 @@ module Discorb
     #
     # @param [String] reason The reason of archiving the thread.
     #
-    # @return [self] The archived thread.
+    # @return [Async::Task<self>] The archived thread.
     #
     def archive(reason: nil)
       edit(archived: true, reason: reason)
@@ -123,7 +123,7 @@ module Discorb
     #
     # @param [String] reason The reason of locking the thread.
     #
-    # @return [self] The locked thread.
+    # @return [Async::Task<self>] The locked thread.
     #
     def lock(reason: nil)
       edit(archived: true, locked: true, reason: reason)
@@ -134,7 +134,7 @@ module Discorb
     #
     # @param [String] reason The reason of unarchiving the thread.
     #
-    # @return [self] The unarchived thread.
+    # @return [Async::Task<self>] The unarchived thread.
     #
     def unarchive(reason: nil)
       edit(archived: false, reason: reason)
@@ -145,7 +145,7 @@ module Discorb
     #
     # @param [String] reason The reason of unlocking the thread.
     #
-    # @return [self] The unlocked thread.
+    # @return [Async::Task<self>] The unlocked thread.
     #
     # @note This method won't unarchive the thread. Use {#unarchive} instead.
     #
@@ -232,7 +232,7 @@ module Discorb
       Async do
         _resp, data = @client.http.request(Route.new("/channels/#{@id}/thread-members",
                                                      "//channels/:channel_id/thread-members", :get)).wait
-        data.map { |d| @members[d[:id]] = Member.new(@client, d) }
+        data.map { |d| @members[d[:id]] = Member.new(@client, d, @guild_id) }
       end
     end
 
@@ -267,11 +267,12 @@ module Discorb
     class Member < DiscordModel
       attr_reader :joined_at
 
-      def initialize(cilent, data)
-        @cilent = cilent
+      def initialize(client, data, guild_id)
+        @client = client
         @thread_id = data[:id]
         @user_id = data[:user_id]
         @joined_at = Time.iso8601(data[:join_timestamp])
+        @guild_id = guild_id
       end
 
       def thread
@@ -279,7 +280,7 @@ module Discorb
       end
 
       def member
-        thread && thread.members[@user_id]
+        @client.guilds[@guild_id].members[@user_id]
       end
 
       def id
@@ -287,7 +288,7 @@ module Discorb
       end
 
       def user
-        @cilent.users[@user_id]
+        @client.users[@user_id]
       end
 
       def inspect
@@ -312,8 +313,11 @@ module Discorb
       @message_count = data[:message_count]
       if data[:member]
         @members[@client.user.id] =
-          ThreadChannel::Member.new(@client,
-                                    data[:member].merge({ id: data[:id], user_id: @client.user.id }))
+          ThreadChannel::Member.new(
+            @client,
+            data[:member].merge({ id: data[:id], user_id: @client.user.id }),
+            @guild_id
+          )
       end
       @data.merge!(data)
     end

data/lib/discorb/client.rb

@@ -66,7 +66,7 @@ module Discorb
     #   @return [Discorb::Shard] The current shard. This is implemented with Thread variables.
     #   @return [nil] If client has no shard.
     # @!attribute [r] shard_id
-    #   @return [Discorb::Shard] The current shard ID. This is implemented with Thread variables.
+    #   @return [Integer] The current shard ID. This is implemented with Thread variables.
     #   @return [nil] If client has no shard.
     # @!attribute [r] logger
     #   @return [Logger] The logger.
@@ -473,9 +473,9 @@ module Discorb
     #
     # Stops the client.
     #
-    def close!
+    def close
       if @shards.any?
-        @shards.each(&:close!)
+        @shards.each_value(&:close)
       else
         @connection.send_close
       end
@@ -512,7 +512,8 @@ module Discorb
     end
 
     def run_setup(token)
-      guild_ids = "global"
+      # @type var guild_ids: Array[String] | false
+      guild_ids = false
       if guilds = ENV.fetch("DISCORB_SETUP_GUILDS", nil)
         guild_ids = guilds.split(",")
       end
@@ -520,9 +521,7 @@ module Discorb
       setup_commands(token, guild_ids: guild_ids).wait
       clear_commands(token, ENV.fetch("DISCORB_SETUP_CLEAR_GUILDS", "").split(","))
       if ENV.fetch("DISCORB_SETUP_SCRIPT", nil) == "true"
-        @events[:setup]&.each do |event|
-          event.call
-        end
+        @events[:setup]&.each(&:call)
         self.on_setup if respond_to? :on_setup
       end
     end
@@ -552,8 +551,9 @@ module Discorb
     end
 
     def session_id=(value)
-      if shard_id
-        @shards[shard_id].session_id = value
+      sid = shard_id
+      if sid
+        @shards[sid].session_id = value
       else
         @session_id = value
       end
@@ -565,18 +565,18 @@ module Discorb
       Signal.trap(:SIGINT) do
         logger.info "SIGINT received, closing..."
         Signal.trap(:SIGINT, "DEFAULT")
-        close!
+        close
       end
       if shards.nil?
         main_loop(nil)
       else
-        @shards = shards.map.with_index do |shard, i|
-          Shard.new(self, shard, shard_count, i)
+        @shards = shards.to_h.with_index do |shard, i|
+          [shard, Shard.new(self, shard, shard_count, i)]
         end
-        @shards[..-1].each_with_index do |shard, i|
-          shard.next_shard = @shards[i + 1]
+        @shards.values[..-1].each_with_index do |shard, i|
+          shard.next_shard = @shards.values[i + 1]
         end
-        @shards.each { |s| s.thread.join }
+        @shards.each_value { |s| s.thread.join }
       end
     end