discorb 0.12.2 → 0.13.1

data/lib/discorb/event.rb

@@ -1,35 +1,277 @@
-# 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.
+    # @async
+    #
+    # @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.
+    #
+    # @return [Async::Task<Discorb::ScheduledEvent>] The event that was created.
+    #
+    # @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
+
+    #
+    # 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 cancel
+      edit(status: :canceled)
+    end
+
+    #
+    # Deletes the event.
+    # @async
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def delete!
+      Async do
+        @client.http.delete("/guilds/#{@guild_id}/scheduled-events/#{@id}").wait
+      end
     end
 
+    alias destroy! delete!
+
+    #
+    # Fetches the event users.
+    # @async
+    #
+    # @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.
     #
-    # Calls the block associated with the event.
+    # @return [Async::Task<Array<Discorb::Member>>] The event users.
     #
-    def call(...)
-      @block.call(...)
+    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/exe/show.rb

@@ -2,7 +2,9 @@
 
 require "etc"
 require "discorb"
+
 puts "\e[90mRuby:\e[m #{RUBY_VERSION}"
 puts "\e[90mdiscorb:\e[m #{Discorb::VERSION}"
 uname = Etc.uname
 puts "\e[90mSystem:\e[m #{uname[:sysname]} #{uname[:release]}"
+puts "\e[90mPlatform:\e[m #{RUBY_PLATFORM}"

data/lib/discorb/extension.rb

@@ -4,7 +4,7 @@ module Discorb
   #
   # Abstract class to make extension.
   # Include from this module to make your own extension.
-  # @see file:docs/extension.md
+  # @see file:docs/extension.md Extension
   # @abstract
   #
   module Extension
@@ -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

@@ -92,10 +92,14 @@ module Discorb
     #
     # @return [Discorb::Flag] The negation of the flag.
     #
-    def ~@
+    def ~
       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

@@ -94,8 +94,7 @@ module Discorb
 
       # Fetch the message.
       # If message is cached, it will be returned.
-      # @macro async
-      # @macro http
+      # @async
       #
       # @param [Boolean] force Whether to force fetching the message.
       #
@@ -143,8 +142,7 @@ module Discorb
 
       # Fetch the message.
       # If message is cached, it will be returned.
-      # @macro async
-      # @macro http
+      # @async
       #
       # @param [Boolean] force Whether to force fetching the message.
       #
@@ -195,8 +193,7 @@ module Discorb
 
       # Fetch the message.
       # If message is cached, it will be returned.
-      # @macro async
-      # @macro http
+      # @async
       #
       # @param [Boolean] force Whether to force fetching the message.
       #
@@ -210,6 +207,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.
     #
@@ -271,8 +290,7 @@ module Discorb
       end
 
       # Fetch the message.
-      # @macro async
-      # @macro http
+      # @async
       #
       # @return [Async::Task<Discorb::Message>] The message.
       def fetch_message
@@ -481,14 +499,14 @@ module Discorb
     module Handler
       private
 
-      def connect_gateway(reconnect)
+      def connect_gateway(reconnect, no_close: false)
         if reconnect
           @log.info "Reconnecting to gateway..."
         else
           @log.info "Connecting to gateway..."
         end
         Async do
-          @connection&.close
+          @connection&.close unless no_close
           @http = HTTP.new(self)
           _, gateway_response = @http.get("/gateway").wait
           gateway_url = gateway_response[:url]
@@ -515,9 +533,9 @@ module Discorb
                   end
                 end
               end
-            rescue Async::Wrapper::Cancelled, OpenSSL::SSL::SSLError, Async::Wrapper::WaitError, EOFError => e
-              @log.error "Gateway connection closed: #{e.class}: #{e.message}"
-              connect_gateway(true)
+            rescue Async::Wrapper::Cancelled, OpenSSL::SSL::SSLError, Async::Wrapper::WaitError, EOFError, Errno::EPIPE => e
+              @log.error "Gateway connection closed accidentally: #{e.class}: #{e.message}"
+              connect_gateway(true, no_close: true)
             else # should never happen
               connect_gateway(true)
             end
@@ -1042,11 +1060,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