discorb 0.12.4 → 0.13.0

data/lib/discorb/event.rb

@@ -1,35 +1,276 @@
-# frozen_string_literal: true
-
 module Discorb
-  #
-  # Represents a event.
-  # This class shouldn't be instantiated directly.
-  # Use {Client#on} instead.
-  #
-  class Event
-    # @return [Proc] the block to be called.
-    attr_reader :block
-    # @return [Symbol] the event id.
+  class ScheduledEvent < DiscordModel
+    @privacy_level = {
+      2 => :guild_only,
+    }
+    @status = {
+      1 => :scheduled,
+      2 => :active,
+      3 => :completed,
+      4 => :canceled,
+    }
+    @entity_type = {
+      1 => :stage_instance,
+      2 => :voice,
+      3 => :external,
+    }
+
+    # @!visibility private
+    def initialize(client, data)
+      @client = client
+      @data = data
+      _set_data(data)
+    end
+
+    #
+    # Represents the metadata of the event.
+    #
+    class Metadata
+      # @return [String, nil] The location of the event. Only present if the event is a external event.
+      attr_reader :location
+      # @!visibility private
+      def initialize(data)
+        @location = data[:location]
+      end
+    end
+
+    # @return [Discorb::Snowflake] The ID of the event.
     attr_reader :id
-    # @return [Hash] the event metadata.
+    # @return [String] The name of the event.
+    attr_reader :name
+    # @return [String] The description of the event.
+    attr_reader :description
+
+    # @return [Time] The time the event starts.
+    attr_reader :scheduled_start_time
+    alias start_time scheduled_start_time
+    alias start_at scheduled_start_time
+    # @return [Time] The time the event ends.
+    attr_reader :scheduled_end_time
+    alias end_time scheduled_end_time
+    alias end_at scheduled_end_time
+    # @return [:guild_only] The privacy level of the event.
+    attr_reader :privacy_level
+    # @return [:scheduled, :active, :completed, :canceled] The status of the event.
+    attr_reader :status
+    # @return [:stage_instance, :voice, :external] The type of the event.
+    attr_reader :entity_type
+    # @return [Discorb::Snowflake] The ID of the entity the event is for.
+    attr_reader :entity_id
+    # @return [Discorb::ScheduledEvent::Metadata] The metadata of the event.
     attr_reader :metadata
-    # @return [Boolean] whether the event is once or not.
-    attr_reader :once
-    alias once? once
+    # @return [Integer] The user count of the event.
+    attr_reader :user_count
+
+    # @!attribute [r] guild
+    #   @return [Discorb::Guild, nil] The guild of the event.
+    # @!attribute [r] channel
+    #   @return [Discorb::Channel, nil] The channel of the event.
+    #     Only present if the event will do in stage instance or voice channel.
+    # @!attribute [r] creator
+    #   @return [Discorb::User] The user who created the event.#
+    # @!attribute [r] time
+    #   @return [Range<Time>] The time range of the event.
+
+    def guild
+      @client.guilds[@guild_id]
+    end
+
+    def channel
+      @client.channels[@channel_id]
+    end
+
+    def creator
+      @creator || @client.users[@creator_id]
+    end
+
+    def time
+      @scheduled_start_time..@scheduled_end_time
+    end
+
+    #
+    # Create a scheduled event for the guild.
+    # @macro async
+    # @macro http
+    #
+    # @param [:stage_instance, :voice, :external] type The type of event to create.
+    # @param [String] name The name of the event.
+    # @param [String] description The description of the event.
+    # @param [Time] start_time The start time of the event.
+    # @param [Time, nil] end_time The end time of the event. Defaults to `nil`.
+    # @param [Discorb::Channel, Discorb::Snowflake, nil] channel The channel to run the event in.
+    # @param [String, nil] location The location of the event. Defaults to `nil`.
+    # @param [:guild_only] privacy_level The privacy level of the event. This must be `:guild_only`.
+    # @param [:active, :completed, :canceled] status The status of the event.
+    #
+    # @see Event#start
+    # @see Event#cancel
+    # @see Event#complete
+    #
+    def edit(
+      type: Discorb::Unset,
+      name: Discorb::Unset,
+      description: Discorb::Unset,
+      start_time: Discorb::Unset,
+      end_time: Discorb::Unset,
+      privacy_level: Discorb::Unset,
+      location: Discorb::Unset,
+      channel: Discorb::Unset,
+      status: Discorb::Unset
+    )
+      Async do
+        payload = case (type == Discorb::Unset) ? @entity_type : type
+          when :stage_instance
+            raise ArgumentError, "channel must be provided for stage_instance events" unless channel
+            {
+              name: name,
+              description: description,
+              scheduled_start_time: start_time.iso8601,
+              scheduled_end_time: end_time&.iso8601,
+              privacy_level: Discorb::ScheduledEvent.privacy_level.key(privacy_level) || Discorb::Unset,
+              channel_id: channel&.id,
+              entity_type: Discorb::ScheduledEvent.entity_type.key(:stage_instance),
+              status: Discorb::ScheduledEvent.status.key(status) || Discorb::Unset,
+            }.reject { |_, v| v == Discorb::Unset }
+          when :voice
+            raise ArgumentError, "channel must be provided for voice events" unless channel
+            {
+              name: name,
+              description: description,
+              scheduled_start_time: start_time.iso8601,
+              scheduled_end_time: end_time&.iso8601,
+              privacy_level: Discorb::ScheduledEvent.privacy_level.key(privacy_level) || Discorb::Unset,
+              channel_id: channel&.id,
+              entity_type: Discorb::ScheduledEvent.entity_type.key(:voice),
+              status: Discorb::ScheduledEvent.status.key(status) || Discorb::Unset,
+            }.reject { |_, v| v == Discorb::Unset }
+          when :external
+            raise ArgumentError, "location must be provided for external events" unless location
+            raise ArgumentError, "end_time must be provided for external events" unless end_time
+            {
+              name: name,
+              description: description,
+              channel_id: nil,
+              scheduled_start_time: start_time.iso8601,
+              scheduled_end_time: end_time.iso8601,
+              privacy_level: Discorb::ScheduledEvent.privacy_level.key(privacy_level) || Discorb::Unset,
+              entity_type: Discorb::ScheduledEvent.entity_type.key(:external),
+              entity_metadata: {
+                location: location,
+              },
+              status: Discorb::ScheduledEvent.status.key(status) || Discorb::Unset,
+            }.reject { |_, v| v == Discorb::Unset }
+          else
+            raise ArgumentError, "Invalid scheduled event type: #{type}"
+          end
+        @client.http.patch("/guilds/#{@guild_id}/scheduled-events/#{@id}", payload).wait
+      end
+    end
+
+    alias modify edit
 
-    def initialize(block, id, metadata)
-      @block = block
-      @id = id
-      @once = metadata.fetch(:once, false)
-      @metadata = metadata
-      @rescue = nil
+    #
+    # Starts the event. Shortcut for `edit(status: :active)`.
+    #
+    def start
+      edit(status: :active)
     end
 
     #
-    # Calls the block associated with the event.
+    # Completes the event. Shortcut for `edit(status: :completed)`.
+    #
+    def complete
+      edit(status: :completed)
+    end
+
+    alias finish complete
+
+    #
+    # Cancels the event. Shortcut for `edit(status: :canceled)`.
     #
-    def call(...)
-      @block.call(...)
+    def cancel
+      edit(status: :canceled)
+    end
+
+    #
+    # Deletes the event.
+    # @macro async
+    # @macro http
+    #
+    def delete!
+      Async do
+        @client.http.delete("/guilds/#{@guild_id}/scheduled-events/#{@id}").wait
+      end
+    end
+
+    alias destroy! delete!
+
+    #
+    # Fetches the event users.
+    # @macro async
+    # @macro http
+    #
+    # @note You can fetch all of members by not specifying a parameter.
+    #
+    # @param [Integer] limit The maximum number of users to fetch. Defaults to `100`.
+    # @param [#to_s] after The ID of the user to start fetching from. Defaults to `nil`.
+    # @param [#to_s] before The ID of the user to stop fetching at. Defaults to `nil`.
+    # @param [Boolean] with_member Whether to include the member object of the event. Defaults to `false`.
+    #   This should be used for manual fetching of members.
+    #
+    # @return [Array<Discorb::Member>] The event users.
+    #
+    def fetch_users(limit = nil, before: nil, after: nil, with_member: true)
+      Async do
+        if limit.nil?
+          after = 0
+          res = []
+          while true
+            _resp, users = @client.http.get("/guilds/#{@guild_id}/scheduled-events/#{@id}/users?limit=100&after=#{after}&with_member=true").wait
+            if users.empty?
+              break
+            end
+            res += users.map { |u| Member.new(@client, @guild_id, u[:user], u[:member]) }
+            after = users.last[:user][:id]
+          end
+          res
+        else
+          params = {
+            limit: limit,
+            before: Discorb::Utils.try(after, :id),
+            after: Discorb::Utils.try(around, :id),
+            with_member: with_member,
+          }.filter { |_k, v| !v.nil? }.to_h
+          _resp, messages = @client.http.get("/channels/#{channel_id.wait}/messages?#{URI.encode_www_form(params)}").wait
+          messages.map { |m| Message.new(@client, m.merge({ guild_id: @guild_id.to_s })) }
+        end
+      end
+    end
+
+    alias fetch_members fetch_users
+
+    private
+
+    def _set_data(data)
+      @id = Snowflake.new(data[:id])
+      @guild_id = Snowflake.new(data[:guild_id])
+      @channel_id = data[:channel_id] && Snowflake.new(data[:channel_id])
+      @creator_id = data[:creator_id] && Snowflake.new(data[:creator_id])
+      @name = data[:name]
+      @description = data[:description]
+      @scheduled_start_time = Time.iso8601(data[:scheduled_start_time])
+      @scheduled_end_time = data[:scheduled_end_time] && Time.iso8601(data[:scheduled_end_time])
+      @privacy_level = :guild_only # data[:privacy_level]
+      @status = self.class.status[data[:status]]
+      @entity_type = self.class.entity_type[data[:entity_type]]
+      @entity_id = data[:entity_id] && Snowflake.new(data[:entity_id])
+      @entity_metadata = data[:entity_metadata] && Metadata.new(data[:entity_metadata])
+      @creator = @client.users[@creator_id] || (data[:creator] && User.new(@client, data[:creator]))
+      @user_count = data[:user_count]
+    end
+
+    class << self
+      attr_reader :status, :entity_type, :privacy_level
     end
   end
 end

data/lib/discorb/event_handler.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a event handler.
+  # This class shouldn't be instantiated directly.
+  # Use {Client#on} instead.
+  #
+  class EventHandler
+    # @return [Proc] the block to be called.
+    attr_reader :block
+    # @return [Symbol] the event id.
+    attr_reader :id
+    # @return [Hash] the event metadata.
+    attr_reader :metadata
+    # @return [Boolean] whether the event is once or not.
+    attr_reader :once
+    alias once? once
+
+    def initialize(block, id, metadata)
+      @block = block
+      @id = id
+      @once = metadata.fetch(:once, false)
+      @metadata = metadata
+      @rescue = nil
+    end
+
+    def inspect
+      "#<#{self.class} @id=#{@id}"
+    end
+
+    #
+    # Calls the block associated with the event.
+    #
+    def call(...)
+      @block.call(...)
+    end
+  end
+end

data/lib/discorb/extension.rb

@@ -17,7 +17,7 @@ module Discorb
       ret = {}
       self.class.events.each do |event, handlers|
         ret[event] = handlers.map do |handler|
-          Discorb::Event.new(Proc.new { |*args, **kwargs| instance_exec(*args, **kwargs, &handler[2]) }, handler[0], handler[1])
+          Discorb::EventHandler.new(Proc.new { |*args, **kwargs| instance_exec(*args, **kwargs, &handler[2]) }, handler[0], handler[1])
         end
       end
       @events = ret
@@ -38,7 +38,7 @@ module Discorb
       # @param [Symbol] id The id of the event. Used to delete the event.
       # @param [Hash] metadata Other metadata.
       #
-      # @return [Discorb::Event] The event.
+      # @return [Discorb::EventHandler] The event.
       #
       def event(event_name, id: nil, **metadata, &block)
         raise ArgumentError, "Event name must be a symbol" unless event_name.is_a?(Symbol)
@@ -57,13 +57,13 @@ module Discorb
       # @param [Hash] metadata Other metadata.
       # @param [Proc] block The block to execute when the event is triggered.
       #
-      # @return [Discorb::Event] The event.
+      # @return [Discorb::EventHandler] The event.
       #
       def once_event(event_name, id: nil, **metadata, &block)
         event(event_name, id: id, once: true, **metadata, &block)
       end
 
-      # @return [Hash{Symbol => Array<Discorb::Event>}] The events of the extension.
+      # @return [Hash{Symbol => Array<Discorb::EventHandler>}] The events of the extension.
       attr_reader :events
       # @return [Array<Discorb::ApplicationCommand::Command>] The commands of the extension.
       attr_reader :commands

data/lib/discorb/file.rb

@@ -89,5 +89,9 @@ module Discorb
       filename ||= string.object_id.to_s + ".txt"
       new(io, filename, content_type: content_type)
     end
+
+    def inspect
+      "#<#{self.class} filename=#{@filename} content_type=#{@content_type}>"
+    end
   end
 end

data/lib/discorb/flag.rb

@@ -96,6 +96,10 @@ module Discorb
       self.class.new(~@value)
     end
 
+    def inspect
+      "#<#{self.class}: #{@value}>"
+    end
+
     class << self
       # @return [Hash{Integer => Symbol}] the bits of the flag.
       attr_reader :bits

data/lib/discorb/gateway.rb

@@ -210,6 +210,28 @@ module Discorb
       end
     end
 
+    #
+    # Represents a `GUILD_SCHEDULED_EVENT_USER_ADD` and `GUILD_SCHEDULED_EVENT_USER_REMOVE` event.
+    #
+    class ScheduledEventUserEvent < GatewayEvent
+      # @return [Discorb::User] The user that triggered the event.
+      attr_reader :user
+      # @return [Discorb::Guild] The guild the event was triggered in.
+      attr_reader :guild
+      # @return [Discorb::ScheduledEvent] The scheduled event.
+      attr_reader :scheduled_event
+      # @private
+      def initialize(client, data)
+        @client = client
+        @scheduled_event_id = Snowflake.new(data[:scheduled_event_id])
+        @user_id = Snowflake.new(data[:user_id])
+        @guild_id = Snowflake.new(data[:guild_id])
+        @guild = client.guilds[data[:guild_id]]
+        @scheduled_event = @guild.scheduled_events[@scheduled_event_id]
+        @user = client.users[data[:user_id]]
+      end
+    end
+
     #
     # Represents a `MESSAGE_UPDATE` event.
     #
@@ -1042,11 +1064,44 @@ module Discorb
           @log.info("Successfully resumed connection")
           @tasks << handle_heartbeat
           dispatch(:resumed)
+        when "GUILD_SCHEDULED_EVENT_CREATE"
+          @log.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
+          event = ScheduledEvent.new(self, data)
+          guild.scheduled_events[data[:id]] = event
+          dispatch(:scheduled_event_create, event)
+        when "GUILD_SCHEDULED_EVENT_UPDATE"
+          @log.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
+          @log.warn("Unknown scheduled event id #{data[:id]}, ignoring") unless (event = guild.scheduled_events[data[:id]])
+          old = event.dup
+          event.send(:_set_data, data)
+          dispatch(:scheduled_event_update, old, event)
+          if old.status != event.status
+            case event.status
+            when :active
+              dispatch(:scheduled_event_start, event)
+            when :completed
+              dispatch(:scheduled_event_end, event)
+            end
+          else
+            dispatch(:scheduled_event_edit, old, event)
+          end
+        when "GUILD_SCHEDULED_EVENT_DELETE"
+          @log.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
+          @log.warn("Unknown scheduled event id #{data[:id]}, ignoring") unless (event = guild.scheduled_events[data[:id]])
+          guild.scheduled_events.remove(data[:id])
+          dispatch(:scheduled_event_delete, event)
+          dispatch(:scheduled_event_cancel, event)
+        when "GUILD_SCHEDULED_EVENT_USER_ADD"
+          @log.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
+          dispatch(:scheduled_event_user_add, ScheduledEventUserEvent.new(self, data))
+        when "GUILD_SCHEDULED_EVENT_USER_REMOVE"
+          @log.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
+          dispatch(:scheduled_event_user_remove, ScheduledEventUserEvent.new(self, data))
         else
           if respond_to?("event_" + event_name.downcase)
             __send__("event_" + event_name.downcase, data)
           else
-            @log.debug "#{event_name}\n#{data.inspect}"
+            @log.debug "Unhandled event: #{event_name}\n#{data.inspect}"
           end
         end
       end

data/lib/discorb/gateway_requests.rb

@@ -39,6 +39,10 @@ module Discorb
       }
     end
 
+    def inspect
+      "#<#{self.class} @type=#{@type}>"
+    end
+
     class << self
       # @private
       attr_reader :types

data/lib/discorb/guild.rb

@@ -96,6 +96,9 @@ module Discorb
     # @return [Boolean] Whether the guild is available.
     attr_reader :available
     alias available? available
+    # @return [Dictionary{Discorb::Snowflake => Discorb::ScheduledEvent}] A dictionary of scheduled events in the guild.
+    attr_reader :scheduled_events
+    alias events scheduled_events
 
     # @!attribute [r] afk_channel
     #   @return [Discorb::VoiceChannel] The AFK channel for this guild.
@@ -169,6 +172,113 @@ module Discorb
       end
     end
 
+    #
+    # Fetch scheduled events for the guild.
+    # @macro async
+    # @macro http
+    #
+    # @param [Boolean] with_user_count Whether to include the user count in the events.
+    #   Defaults to `true`.
+    #
+    # @return [Array<Discorb::ScheduledEvent>] The events for the guild.
+    #
+    def fetch_scheduled_events(with_user_count: true)
+      Async do
+        _resp, events = @client.http.get("/guilds/#{@id}/scheduled-events?with_user_count=#{with_user_count}").wait
+        @scheduled_events = events.map { |e| ScheduledEvent.new(@client, e) }
+      end
+    end
+
+    #
+    # Fetch the scheduled event by ID.
+    # @macro async
+    # @macro http
+    #
+    # @param [#to_s] id The ID of the scheduled event.
+    #
+    # @return [Discorb::ScheduledEvent] The event with the given ID.
+    # @return [nil] If no event with the given ID exists.
+    #
+    def fetch_scheduled_event(id)
+      Async do
+        _resp, event = @client.http.get("/guilds/#{@id}/scheduled-events/#{id}").wait
+      rescue Discorb::NotFoundError
+        return nil
+      else
+        ScheduledEvent.new(@client, event)
+      end
+    end
+
+    #
+    # Create a scheduled event for the guild.
+    #
+    # @param [:stage_instance, :voice, :external] type The type of event to create.
+    # @param [String] name The name of the event.
+    # @param [String] description The description of the event.
+    # @param [Time] start_time The start time of the event.
+    # @param [Time, nil] end_time The end time of the event. Defaults to `nil`.
+    # @param [Discorb::Channel, Discorb::Snowflake, nil] channel The channel to run the event in.
+    # @param [String, nil] location The location of the event. Defaults to `nil`.
+    # @param [:guild_only] privacy_level The privacy level of the event. This must be `:guild_only`.
+    #
+    # @return [Discorb::ScheduledEvent] The created event.
+    #
+    def create_scheduled_event(
+      type,
+      name,
+      description,
+      start_time,
+      end_time = nil,
+      privacy_level: :guild_only,
+      location: nil,
+      channel: nil
+    )
+      Async do
+        payload = case type
+          when :stage_instance
+            raise ArgumentError, "channel must be provided for stage_instance events" unless channel
+            {
+              name: name,
+              description: description,
+              scheduled_start_time: start_time.iso8601,
+              scheduled_end_time: end_time&.iso8601,
+              privacy_level: Discorb::ScheduledEvent.privacy_level.key(privacy_level),
+              channel_id: channel&.id,
+              entity_type: Discorb::ScheduledEvent.entity_type.key(:stage_instance),
+            }
+          when :voice
+            raise ArgumentError, "channel must be provided for voice events" unless channel
+            {
+              name: name,
+              description: description,
+              scheduled_start_time: start_time.iso8601,
+              scheduled_end_time: end_time&.iso8601,
+              privacy_level: Discorb::ScheduledEvent.privacy_level.key(privacy_level),
+              channel_id: channel&.id,
+              entity_type: Discorb::ScheduledEvent.entity_type.key(:voice),
+            }
+          when :external
+            raise ArgumentError, "location must be provided for external events" unless location
+            raise ArgumentError, "end_time must be provided for external events" unless end_time
+            {
+              name: name,
+              description: description,
+              scheduled_start_time: start_time.iso8601,
+              scheduled_end_time: end_time.iso8601,
+              privacy_level: Discorb::ScheduledEvent.privacy_level.key(privacy_level),
+              entity_type: Discorb::ScheduledEvent.entity_type.key(:external),
+              entity_metadata: {
+                location: location,
+              },
+            }
+          else
+            raise ArgumentError, "Invalid scheduled event type: #{type}"
+          end
+        _resp, event = @client.http.post("/guilds/#{@id}/scheduled-events", payload).wait
+        Discorb::ScheduledEvent.new(@client, event)
+      end
+    end
+
     #
     # Fetch emoji list of the guild.
     # @macro async
@@ -1143,6 +1253,7 @@ module Discorb
       @presences = Dictionary.new(data[:presences].map { |pr| [Snowflake.new(pr[:user][:id]), Presence.new(@client, pr)] }.to_h)
       @max_presences = data[:max_presences]
       @stage_instances = Dictionary.new(data[:stage_instances].map { |s| [Snowflake.new(s[:id]), StageInstance.new(@client, s)] }.to_h)
+      @scheduled_events = Dictionary.new(data[:guild_scheduled_events].map { |s| [Snowflake.new(s[:id]), ScheduledEvent.new(@client, s)] }.to_h)
       @data.update(data)
     end
   end
@@ -1155,12 +1266,14 @@ module Discorb
   # |`1 << 0`|`:member_join`|
   # |`1 << 1`|`:server_boost`|
   # |`1 << 2`|`:setup_tips`|
+  # |`1 << 3`|`:join_stickers`|
   #
   class SystemChannelFlag < Flag
     @bits = {
       member_join: 0,
       server_boost: 1,
       setup_tips: 2,
+      join_stickers: 3,
     }.freeze
   end
 

data/lib/discorb/image.rb

@@ -16,12 +16,10 @@ module Discorb
     #
     def initialize(source, type = nil)
       if source.respond_to?(:read)
-        @bytes = source.read
+        @io = source
         @type = type || MIME::Types.type_for(source.path).first.content_type
       elsif ::File.exist?(source)
-        ::File.open(source, "rb") do |file|
-          @bytes = file.read
-        end
+        @io = ::File.open(source, "rb")
         @type = MIME::Types.type_for(source).first.to_s
       else
         raise ArgumentError, "Couldn't read file."
@@ -34,7 +32,11 @@ module Discorb
     # @return [String] The image as a Discord style.
     #
     def to_s
-      "data:#{@type};base64,#{Base64.strict_encode64(@bytes)}"
+      "data:#{@type};base64,#{Base64.strict_encode64(@io.read)}"
+    end
+
+    def inspect
+      "#<#{self.class} #{@type}>"
     end
   end
 end