discorb 0.0.8 → 0.2.3

data/lib/discorb/http.rb

@@ -227,7 +227,7 @@ module Discorb
     end
 
     def get_headers(headers, body = "", audit_log_reason = nil)
-      ret = if body.nil? || body.empty?
+      ret = if body.nil? || body == ""
           { "User-Agent" => USER_AGENT, "authorization" => "Bot #{@client.token}" }
         else
           { "User-Agent" => USER_AGENT, "authorization" => "Bot #{@client.token}",

data/lib/discorb/interaction.rb

@@ -75,11 +75,15 @@ module Discorb
 
       # @!visibility private
       def make_interaction(client, data)
+        interaction = nil
         descendants.each do |klass|
-          return klass.make_interaction(client, data) if !klass.interaction_type.nil? && klass.interaction_type == data[:type]
+          interaction = klass.make_interaction(client, data) if !klass.interaction_type.nil? && klass.interaction_type == data[:type]
         end
-        client.log.warn("Unknown interaction type #{data[:type]}, initialized Interaction")
-        Interaction.new(client, data)
+        if interaction.nil?
+          client.log.warn("Unknown interaction type #{data[:type]}, initialized Interaction")
+          interaction = Interaction.new(client, data)
+        end
+        interaction
       end
 
       # @!visibility private
@@ -95,14 +99,14 @@ module Discorb
       #
       # Response with `DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE`(`5`).
       #
-      # @param [Boolean] hide Whether to hide the response (ephemeral).
+      # @param [Boolean] ephemeral Whether to make the response ephemeral.
       #
-      def defer_source(hide: false)
+      def defer_source(ephemeral: false)
         Async do
           @client.http.post("/interactions/#{@id}/#{@token}/callback", {
             type: 5,
             data: {
-              flags: (hide ? 1 << 6 : 0),
+              flags: (ephemeral ? 1 << 6 : 0),
             },
           }).wait
           @defered = true
@@ -118,9 +122,9 @@ module Discorb
       # @param [Array<Discorb::Embed>] embeds The embeds to send. (max: 10)
       # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions to send.
       # @param [Array<Discorb::Components>, Array<Array<Discorb::Components>>] components The components to send.
-      # @param [Boolean] hide Whether to hide the response (ephemeral).
+      # @param [Boolean] ephemeral Whether to make the response ephemeral.
       #
-      def post(content, tts: false, embed: nil, embeds: nil, allowed_mentions: nil, components: nil, hide: false)
+      def post(content = nil, tts: false, embed: nil, embeds: nil, allowed_mentions: nil, components: nil, ephemeral: false)
         payload = {}
         payload[:content] = content if content
         payload[:tts] = tts
@@ -151,7 +155,7 @@ module Discorb
           tmp_components << tmp_row
           payload[:components] = tmp_components.filter { |c| c.length.positive? }.map { |c| { type: 1, components: c.map(&:to_hash) } }
         end
-        payload[:flags] = (hide ? 1 << 6 : 0)
+        payload[:flags] = (ephemeral ? 1 << 6 : 0)
         if @responded
           @client.http.post("/webhooks/#{@id}/#{@token}", { type: 4, data: payload }).wait
         elsif @defered
@@ -170,14 +174,14 @@ module Discorb
       #
       # Response with `DEFERRED_UPDATE_MESSAGE`(`6`).
       #
-      # @param [Boolean] hide Whether to hide the response (ephemeral).
+      # @param [Boolean] ephemeral Whether to make the response ephemeral.
       #
-      def defer_update(hide: false)
+      def defer_update(ephemeral: false)
         Async do
           @client.http.post("/interactions/#{@id}/#{@token}/callback", {
             type: 7,
             data: {
-              flags: (hide ? 1 << 6 : 0),
+              flags: (ephemeral ? 1 << 6 : 0),
             },
           }).wait
         end
@@ -192,9 +196,9 @@ module Discorb
       # @param [Array<Discorb::Embed>] embeds The embeds to send. (max: 10)
       # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions to send.
       # @param [Array<Discorb::Components>, Array<Array<Discorb::Components>>] components The components to send.
-      # @param [Boolean] hide Whether to hide the response (ephemeral).
+      # @param [Boolean] ephemeral Whether to make the response ephemeral.
       #
-      def edit(content, tts: false, embed: nil, embeds: nil, allowed_mentions: nil, components: nil, hide: false)
+      def edit(content, tts: false, embed: nil, embeds: nil, allowed_mentions: nil, components: nil, ephemeral: false)
         payload = {}
         payload[:content] = content if content
         payload[:tts] = tts
@@ -225,7 +229,7 @@ module Discorb
           tmp_components << tmp_row
           payload[:components] = tmp_components.filter { |c| c.length.positive? }.map { |c| { type: 1, components: c.map(&:to_hash) } }
         end
-        payload[:flags] = (hide ? 1 << 6 : 0)
+        payload[:flags] = (ephemeral ? 1 << 6 : 0)
         @client.http.post("/interactions/#{@id}/#{@token}/callback", { type: 6, data: payload }).wait
       end
     end
@@ -238,15 +242,123 @@ module Discorb
   end
 
   #
-  # Represents a slash command interaction.
+  # Represents a command interaction.
   # @todo Implement this.
   #
-  class SlashCommandInteraction < Interaction
+  class CommandInteraction < Interaction
     @interaction_type = 2
-    @interaction_name = :slash_command
+    @interaction_name = :application_command
+    include Interaction::SourceResponse
+
+    #
+    # Represents a slash command interaction.
+    #
+    class SlashCommand < CommandInteraction
+      @command_type = 1
+
+      def _set_data(data)
+        super
+        Sync do
+          name = data[:name]
+          options = nil
+          if (option = data[:options]&.first)
+            case option[:type]
+            when 1
+              name += " #{option[:name]}"
+              options = option[:options]
+            when 2
+              name += " #{option[:name]}"
+              if (option_sub = option[:options]&.first)
+                if option_sub[:type] == 1
+                  name += " #{option_sub[:name]}"
+                  options = option_sub[:options]
+                else
+                  options = option[:options]
+                end
+              end
+            else
+              options = data[:options]
+            end
+          end
+          options ||= []
+          options.map! do |option|
+            case option[:type]
+            when 3, 4, 5, 10
+              option[:value]
+            when 6
+              guild.members[option[:value]] || guild.fetch_member(option[:value]).wait
+            when 7
+              guild.channels[option[:value]] || guild.fetch_channels.wait.find { |channel| channel.id == option[:value] }
+            when 8
+              guild.roles[option[:value]] || guild.fetch_roles.wait.find { |role| role.id == option[:value] }
+            when 9
+              guild.members[option[:value]] || guild.roles[option[:value]] || guild.fetch_member(option[:value]).wait || guild.fetch_roles.wait.find { |role| role.id == option[:value] }
+            end
+          end
+
+          unless (command = @client.commands.find { |c| c.to_s == name })
+            @client.log.warn "Unknown command name #{name}, ignoreing"
+            next
+          end
+
+          command.block.call(self, *options)
+        end
+      end
+    end
+
+    #
+    # Represents a user context menu interaction.
+    #
+    class UserMenuCommand < CommandInteraction
+      @command_type = 2
+
+      # @return [Discorb::Member, Discorb::User] The target user.
+      attr_reader :target
+
+      def _set_data(data)
+        @target = guild.members[data[:target_id]] || Discorb::Member.new(@client, @guild_id, data[:resolved][:users][data[:target_id].to_sym], data[:resolved][:members][data[:target_id].to_sym])
+        @client.commands.find { |c| c.name == data[:name] && c.type_raw == 2 }.block.call(self, @target)
+      end
+    end
+
+    #
+    # Represents a message context menu interaction.
+    #
+    class MessageMenuCommand < CommandInteraction
+      @command_type = 3
+
+      # @return [Discorb::Message] The target message.
+      attr_reader :target
+
+      def _set_data(data)
+        @target = Message.new(@client, data[:resolved][:messages][data[:target_id].to_sym].merge({ guild_id: @guild_id.to_s }))
+        @client.commands.find { |c| c.name == data[:name] && c.type_raw == 3 }.block.call(self, @target)
+      end
+    end
+
+    private
 
     def _set_data(data)
-      p data
+      @name = data[:name]
+    end
+
+    class << self
+      # @!visibility private
+      attr_reader :command_type
+
+      # @!visibility private
+      def make_interaction(client, data)
+        nested_classes.each do |klass|
+          return klass.new(client, data) if !klass.command_type.nil? && klass.command_type == data[:data][:type]
+        end
+        client.log.warn("Unknown command type #{data[:type]}, initialized CommandInteraction")
+        CommandInteraction.new(client, data)
+      end
+
+      # @!visibility private
+      def nested_classes
+        constants.select { |c| const_get(c).is_a? Class }.map { |c| const_get(c) }
+      end
     end
   end
 

data/lib/discorb/log.rb

@@ -61,7 +61,7 @@ module Discorb
       return unless @out
 
       if @colorize_log
-        @out.puts("[#{Time.now.iso8601}] #{color}#{name}\e[m -- #{message}")
+        @out.puts("\e[2;90m[#{Time.now.iso8601}] #{color}#{name}\e[m -- #{message}")
       else
         @out.puts("[#{Time.now.iso8601}] #{name} -- #{message}")
       end

data/lib/discorb/member.rb

@@ -78,6 +78,15 @@ module Discorb
       "@#{name}"
     end
 
+    #
+    # Format the member to `Username#Discriminator` style.
+    #
+    # @return [String] The formatted member.
+    #
+    def to_s_user
+      "#{username}##{discriminator}"
+    end
+
     def name
       @nick || @username
     end
@@ -223,8 +232,8 @@ module Discorb
       @hoisted_role_id = member_data[:hoisted_role]
       @deaf = member_data[:deaf]
       @custom_avatar = member_data[:avatar] && Asset.new(member_data[:avatar])
-      @display_avatar = Asset.new(self, member_data[:avatar] || user_data[:avatar])
       super(user_data)
+      @display_avatar = @avatar || @custom_avatar
       @client.guilds[@guild_id].members[@id] = self unless @guild_id.nil?
       @_member_data.update(member_data)
     end

data/lib/discorb/message.rb

@@ -213,6 +213,33 @@ module Discorb
       !@updated_at.nil?
     end
 
+    #
+    # Edit the message.
+    #
+    # @param [String] content The message content.
+    # @param [Discorb::Embed] embed The embed to send.
+    # @param [Array<Discord::Embed>] embeds The embeds to send.
+    # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions.
+    # @param [Array<Discorb::Component>, Array<Array<Discorb::Component>>] components The components to send.
+    # @param [Boolean] supress Whether to supress embeds.
+    #
+    def edit(...)
+      Async do
+        channel.edit_message(@id, ...).wait
+      end
+    end
+
+    #
+    # Delete the message.
+    #
+    # @param [String] reason The reason for deleting the message.
+    #
+    def delete!(reason: nil)
+      Async do
+        channel.delete_message!(@id, reason: reason).wait
+      end
+    end
+
     #
     # Convert the message to reference object.
     #

data/lib/discorb/modules.rb

@@ -7,6 +7,8 @@ module Discorb
   module Messageable
     #
     # Post a message to the channel.
+    # @macro async
+    # @macro http
     #
     # @param [String] content The message content.
     # @param [Boolean] tts Whether the message is tts.
@@ -61,13 +63,82 @@ module Discorb
         else
           headers = {}
         end
-        _resp, data = @client.http.post("#{base_url.wait}/messages", payload, headers: headers).wait
+        _resp, data = @client.http.post("/channels/#{channel_id.wait}/messages", payload, headers: headers).wait
         Message.new(@client, data.merge({ guild_id: @guild_id.to_s }))
       end
     end
 
+    #
+    # Edit a message.
+    # @macro async
+    # @macro http
+    #
+    # @param [#to_s] message_id The message id.
+    # @param [String] content The message content.
+    # @param [Discorb::Embed] embed The embed to send.
+    # @param [Array<Discord::Embed>] embeds The embeds to send.
+    # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions.
+    # @param [Array<Discorb::Component>, Array<Array<Discorb::Component>>] components The components to send.
+    # @param [Boolean] supress Whether to supress embeds.
+    #
+    def edit_message(message_id, content = nil, embed: nil, embeds: nil, allowed_mentions: nil,
+                                                components: nil, supress: nil)
+      Async do
+        payload = {}
+        payload[:content] = content if content
+        tmp_embed = if embed
+            [embed]
+          elsif embeds
+            embeds
+          end
+        payload[:embeds] = tmp_embed.map(&:to_hash) if tmp_embed
+        payload[:allowed_mentions] =
+          allowed_mentions ? allowed_mentions.to_hash(@client.allowed_mentions) : @client.allowed_mentions.to_hash
+        if components
+          tmp_components = []
+          tmp_row = []
+          components.each do |c|
+            case c
+            when Array
+              tmp_components << tmp_row
+              tmp_row = []
+              tmp_components << c
+            when SelectMenu
+              tmp_components << tmp_row
+              tmp_row = []
+              tmp_components << [c]
+            else
+              tmp_row << c
+            end
+          end
+          tmp_components << tmp_row
+          payload[:flags] = (supress ? 1 << 2 : 0) unless flags.nil?
+          payload[:components] = tmp_components.filter { |c| c.length.positive? }.map { |c| { type: 1, components: c.map(&:to_hash) } }
+        end
+        @client.http.patch("/channels/#{channel_id.wait}/messages/#{message_id}", payload).wait
+      end
+    end
+
+    #
+    # Delete a message.
+    # @macro async
+    # @macro http
+    #
+    # @param [#to_s] message_id The message id.
+    # @param [String] reason The reason for deleting the message.
+    #
+    def delete_message!(message_id, reason: nil)
+      Async do
+        @client.http.delete("/channels/#{channel_id.wait}/messages/#{message_id}", reason: reason).wait
+      end
+    end
+
+    alias destroy_message! delete_message!
+
     #
     # Fetch a message from ID.
+    # @macro async
+    # @macro http
     #
     # @param [Discorb::Snowflake] id The ID of the message.
     #
@@ -76,13 +147,15 @@ module Discorb
     #
     def fetch_message(id)
       Async do
-        _resp, data = @client.http.get("#{base_url.wait}/messages/#{id}").wait
+        _resp, data = @client.http.get("/channels/#{channel_id.wait}/messages/#{id}").wait
         Message.new(@client, data.merge({ guild_id: @guild_id.to_s }))
       end
     end
 
     #
     # Fetch a message history.
+    # @macro async
+    # @macro http
     #
     # @param [Integer] limit The number of messages to fetch.
     # @param [Discorb::Snowflake] before The ID of the message to fetch before.
@@ -99,7 +172,7 @@ module Discorb
           after: Discorb::Utils.try(around, :id),
           around: Discorb::Utils.try(before, :id),
         }.filter { |_k, v| !v.nil? }.to_h
-        _resp, messages = @client.http.get("#{base_url.wait}/messages?#{URI.encode_www_form(params)}").wait
+        _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

data/lib/discorb/user.rb

@@ -21,6 +21,8 @@ module Discorb
     # @return [Boolean] Whether the user is a bot.
     attr_reader :bot
     alias bot? bot
+    # @return [Time] The time the user was created.
+    attr_reader :created_at
 
     include Discorb::Messageable
 
@@ -41,6 +43,8 @@ module Discorb
       "#{@username}##{@discriminator}"
     end
 
+    alias to_s_user to_s
+
     def inspect
       "#<#{self.class} #{self}>"
     end
@@ -70,13 +74,13 @@ module Discorb
     alias app_owner? bot_owner?
 
     # @!visibility private
-    def base_url
+    def channel_id
       Async do
         next @dm_channel_id if @dm_channel_id
 
         dm_channel = @client.http.post("/users/#{@id}/channels", { recipient_id: @client.user.id }).wait
         @dm_channel_id = dm_channel[:id]
-        "/channels/#{@dm_channel_id}"
+        @dm_channel_id
       end
     end
 
@@ -123,10 +127,11 @@ module Discorb
       @id = Snowflake.new(data[:id])
       @flag = User::Flag.new(data[:public_flags] | (data[:flags] || 0))
       @discriminator = data[:discriminator]
-      @avatar = Asset.new(self, data[:avatar])
+      @avatar = data[:avatar] ? Asset.new(self, data[:avatar]) : DefaultAvatar.new(data[:discriminator])
       @bot = data[:bot]
       @raw_data = data
       @client.users[@id] = self if !data[:no_cache] && data.is_a?(User)
+      @created_at = @id.timestamp
       @data.update(data)
     end
   end