discorb 0.0.1

data/examples/simple/ping_pong.rb

@@ -0,0 +1,16 @@
+require "discorb"
+
+client = Discorb::Client.new
+
+client.once :ready do
+  puts "Logged in as #{client.user}"
+end
+
+client.on :message do |_task, message|
+  next if message.author.bot?
+  next unless message.content == "ping"
+
+  message.channel.post("Pong!")
+end
+
+client.run(ENV["DISCORD_BOT_TOKEN"])

data/examples/simple/rolepanel.rb

@@ -0,0 +1,65 @@
+require "discorb"
+intents = Discorb::Intents.new
+intents.members = true
+client = Discorb::Client.new(intents: intents, log: $stdout, colorize_log: true)
+
+def convert_role(guild, string)
+  guild.roles.find do |role|
+    role.id == string || role.name == string || role.mention == string
+  end
+end
+
+client.once :ready do
+  puts "Logged in as #{client.user}"
+end
+
+client.on :reaction_add do |_task, event|
+  next unless event.emoji.value.end_with?(0x0000fe0f.chr("utf-8") + 0x000020e3.chr("utf-8"))
+  next if event.member.bot?
+
+  msg = event.fetch_message.wait
+  if msg.embeds.length.positive? && msg.embeds[0].title == "Role panel" && msg.author == client.user
+    role_ids = msg.embeds[0].description.scan(/(?<=<@&)\d+(?=>)/)
+
+    role = event.guild.roles[role_ids[event.emoji.value[0].to_i - 1]]
+    next if role.nil?
+
+    event.member.add_role(role)
+  end
+end
+
+client.on :reaction_remove do |_task, event|
+  next unless event.emoji.value.end_with?(0x0000fe0f.chr("utf-8") + 0x000020e3.chr("utf-8"))
+  next if event.member.bot?
+
+  msg = event.fetch_message.wait
+  if msg.embeds.length.positive? && msg.embeds[0].title == "Role panel" && msg.author == client.user
+    role_ids = msg.embeds[0].description.scan(/(?<=<@&)\d+(?=>)/)
+
+    role = event.guild.roles[role_ids[event.emoji.value[0].to_i - 1]]
+    next if role.nil?
+
+    event.member.remove_role(role)
+  end
+end
+
+client.on :message do |_task, message|
+  next unless message.content.start_with?("/rp ")
+  next if message.author.bot?
+
+  message.reply("Too many roles.") if message.content.split.length > 10
+  roles = message.content.delete_prefix("/rp ").split.map.with_index { |raw_role, index| [index, convert_role(message.guild, raw_role), raw_role] }
+  if (convert_fails = roles.filter { |r| r[1].nil? }).length.positive?
+    message.reply("#{convert_fails.map { |r| r[2] }.join(", ")} is not a role.")
+    next
+  end
+  rp_msg = message.channel.post(embed: Discorb::Embed.new(
+                                  "Role panel",
+                                  roles.map.with_index(1) { |r, index| "#{index}\ufe0f\u20e3#{r[1].mention}" }.join("\n")
+                                )).wait
+  1.upto(roles.length).each do |i|
+    rp_msg.add_reaction(Discorb::UnicodeEmoji["#{i}\ufe0f\u20e3"]).wait
+  end
+end
+
+client.run(ENV["DISCORD_BOT_TOKEN"])

data/examples/simple/wait_for_message.rb

@@ -0,0 +1,30 @@
+require "discorb"
+
+client = Discorb::Client.new
+
+client.once :ready do
+  puts "Logged in as #{client.user}"
+end
+
+client.on :message do |_task, message|
+  next if message.author.bot?
+  next unless message.content == "!quiz"
+
+  operator = [:+, :-, :*].sample
+  num1 = rand(1..10)
+  num2 = rand(1..10)
+
+  val = num1.send(operator, num2)
+  message.channel.post("Quiz: `#{num1} #{operator} #{num2}`")
+  begin
+    msg = client.event_lock(:message, 30) { |m|
+      m.content == val.to_s && m.channel == message.channel
+    }.wait
+  rescue Discorb::TimeoutError
+    message.channel.post("No one answered...")
+  else
+    msg.reply("Correct!")
+  end
+end
+
+client.run(ENV["DISCORD_BOT_TOKEN"])

data/lib/discorb/application.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a Discord application.
+  #
+  class Application < DiscordModel
+    # @return [Discorb::Snowflake] The application's ID.
+    attr_reader :id
+    # @return [String] The application's name.
+    attr_reader :name
+    # @return [Discorb::Asset] The application's icon.
+    attr_reader :icon
+    # @return [String] The application's description.
+    attr_reader :description
+    # @return [String] The application's summary.
+    attr_reader :summary
+    # @return [String] The application's public key.
+    attr_reader :verify_key
+    # @return [Discorb::User] The application's owner.
+    attr_reader :owner
+    # @return [Discorb::Application::Team] The application's team.
+    attr_reader :team
+    # @return [Boolean] Whether the application's bot is public.
+    attr_reader :bot_public
+    alias bot_public? bot_public
+    # @return [Boolean] Whether the application's bot requires a code grant.
+    attr_reader :bot_require_code_grant
+    alias bot_require_code_grant? bot_require_code_grant
+
+    # @!visibility private
+    def initialize(client, data)
+      @client = client
+      @data = data
+      @id = Snowflake.new(data[:id])
+      @name = data[:name]
+      @icon = Asset.new(self, data[:icon])
+      @description = data[:description]
+      @summary = data[:summary]
+      @bot_public = data[:bot_public]
+      @bot_require_code_grant = data[:bot_require_code_grant]
+      @verify_key = data[:verify_key]
+      @owner = @client.users[data[:owner][:id]] || User.new(@client, data[:owner])
+      @team = data[:team] && Team.new(@client, data[:team])
+    end
+
+    def inspect
+      "#<#{self.class} id=#{@id}>"
+    end
+
+    alias public? bot_public?
+
+    alias require_code_grant? bot_require_code_grant?
+
+    #
+    # Represents a team for an application.
+    #
+    class Team < DiscordModel
+      # @return [Discorb::Snowflake] The team's ID.
+      attr_reader :id
+      # @return [Discorb::Asset] The team's icon.
+      attr_reader :icon
+      # @return [String] The team's name.
+      attr_reader :name
+      # @return [Discorb::Snowflake] The team's owner's ID.
+      attr_reader :owner_user_id
+      # @return [Discorb::Application::Team::Member] The team's member.
+      attr_reader :members
+
+      # @!visibility private
+      def initialize(client, data)
+        @client = client
+        @id = Snowflake.new(data[:id])
+        @icon = Asset.new(self, data[:icon])
+        @name = data[:name]
+        @owner_user_id = data[:owner_user_id]
+        @members = data[:members].map { |m| Team::Member.new(@client, self, m) }
+      end
+
+      #
+      # The team's owner.
+      #
+      # @return [Discorb::Application::Team::Member] The team's owner.
+      #
+      def owner
+        @members.find { |m| m.user.id == @owner_user_id }
+      end
+
+      def inspect
+        "#<#{self.class} id=#{@id}>"
+      end
+
+      #
+      # Represents a member of team.
+      #
+      class Member < DiscordModel
+        # @return [Discorb::User] The user.
+        attr_reader :user
+        # @return [Snowflake] The ID of member's team.
+        attr_reader :team_id
+        # @return [:invited, :accepted] The member's membership state.
+        attr_reader :membership_state
+        alias state membership_state
+        # @return [Array<Permissions>] The permissions of the member.
+        # @note This always return `:*`.
+        attr_reader :permissions
+
+        # @!attribute [r] pending?
+        #   @return [Boolean] Whether the member is not joined to the team.
+        # @!attribute [r] accepted?
+        #   @return [Boolean] Whether the member accepted joining the team.
+        # @!attribute [r] owner?
+        #   @return [Boolean] Whether the member is the team's owner.
+
+        @membership_state = {
+          1 => :invited,
+          2 => :accepted,
+        }.freeze
+
+        def initialize(client, team, data)
+          @client = client
+          @data = data
+          @team = team
+          @user = client.users[data[:user][:id]] || User.new(client, data[:user])
+          @team_id = Snowflake.new(data[:team_id])
+          @membership_state = self.class.membership_state[data[:membership_state]]
+          @permissions = data[:permissions].map(&:to_sym)
+        end
+
+        def pending?
+          @membership_state == :invited
+        end
+
+        def accepted?
+          @membership_state == :accepted
+        end
+
+        def inspect
+          "#<#{self.class} id=#{@user.id}>"
+        end
+
+        def owner?
+          @team.owner_user_id == @user.id
+        end
+
+        def ==(other)
+          super || @user == other
+        end
+
+        class << self
+          # @!visibility private
+          attr_reader :membership_state
+        end
+      end
+    end
+  end
+end

data/lib/discorb/asset.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a single asset.
+  #
+  class Asset < DiscordModel
+    # @return [String] The hash of asset.
+    attr_reader :hash
+
+    # @!attribute [r] animated?
+    #   @return [Boolean] Whether the asset is animated.
+
+    # @!visibility private
+    def initialize(target, hash, path: nil)
+      @hash = hash
+      @target = target
+      @path = path
+    end
+
+    def animated?
+      @hash.start_with? "a_"
+    end
+
+    #
+    # URL of the asset.
+    #
+    # @param [String] image_format The image format.
+    # @param [Integer] size The size of the image.
+    #
+    # @return [String] URL of the asset.
+    #
+    def url(image_format: nil, size: 1024)
+      path = @path || "#{endpoint}/#{@target.id}"
+      "https://cdn.discordapp.com/#{path}/#{@hash}.#{image_format or (animated? ? "gif" : "webp")}?size=#{size}"
+    end
+
+    def inspect
+      "#<#{self.class} #{@target.class} #{@hash}>"
+    end
+
+    private
+
+    def endpoint
+      case @target
+      when User, Member, Webhook
+        "avatars"
+      when Guild, IncomingWebhook::Guild
+        "icons"
+      when Application
+        "app-icons"
+      when Application::Team
+        "team-icons"
+      end
+    end
+  end
+end

data/lib/discorb/audit_logs.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a Discord audit log.
+  #
+  class AuditLog < DiscordModel
+    # @return [Array<Discorb::Webhook>] The webhooks in this audit log.
+    attr_reader :webhooks
+    # @return [Array<Discorb::User>] The users in this audit log.
+    attr_reader :users
+    # @return [Array<Discorb::ThreadChannel>] The threads in this audit log.
+    attr_reader :threads
+    # @return [Array<Discorb::AuditLog::Entry>] The entries in this audit log.
+    attr_reader :entries
+
+    # @!visibility private
+    def initialize(client, data, guild)
+      @client = client
+      @guild = guild
+      @webhooks = data[:webhooks].map { |webhook| Webhook.new([@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) }
+      @entries = data[:audit_log_entries].map { |entry| AuditLog::Entry.new(@client, entry, guild.id) }
+    end
+
+    #
+    # Gets an entry from entries.
+    #
+    # @param [Integer] index The index of the entry.
+    #
+    # @return [Discorb::AuditLog::Entry] The entry.
+    # @return [nil] If the index is out of range.
+    #
+    def [](index)
+      @entries[index]
+    end
+
+    #
+    # Represents an entry in an audit log.
+    #
+    class Entry < DiscordModel
+      # @return [Discorb::Snowflake] The ID of the entry.
+      attr_reader :id
+      # @return [Discorb::Snowflake] The ID of the user who performed the action.
+      attr_reader :user_id
+      # @return [Discorb::Snowflake] The ID of the target of the action.
+      attr_reader :target_id
+      # @return [Symbol] The type of the entry.
+      # These symbols will be used:
+      #
+      # * `:guild_update`
+      # * `:channel_create`
+      # * `:channel_update`
+      # * `:channel_delete`
+      # * `:channel_overwrite_create`
+      # * `:channel_overwrite_update`
+      # * `:channel_overwrite_delete`
+      # * `:member_kick`
+      # * `:member_prune`
+      # * `:member_ban_add`
+      # * `:member_ban_remove`
+      # * `:member_update`
+      # * `:member_role_update`
+      # * `:member_move`
+      # * `:member_disconnect`
+      # * `:bot_add`
+      # * `:role_create`
+      # * `:role_update`
+      # * `:role_delete`
+      # * `:invite_create`
+      # * `:invite_update`
+      # * `:invite_delete`
+      # * `:webhook_create`
+      # * `:webhook_update`
+      # * `:webhook_delete`
+      # * `:emoji_create`
+      # * `:emoji_update`
+      # * `:emoji_delete`
+      # * `:message_delete`
+      # * `:message_bulk_delete`
+      # * `:message_pin`
+      # * `:message_unpin`
+      # * `:integration_create`
+      # * `:integration_update`
+      # * `:integration_delete`
+      # * `:stage_instance_create`
+      # * `:stage_instance_update`
+      # * `:stage_instance_delete`
+      # * `:sticker_create`
+      # * `:sticker_update`
+      # * `:sticker_delete`
+      # * `:thread_create`
+      # * `:thread_update`
+      # * `:thread_delete`
+      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.
+      attr_reader :target
+      # @return [Hash{Symbol => Object}] The optional data for this entry.
+      # @note You can use dot notation to access the data.
+      attr_reader :options
+
+      # @!attribute [r] user
+      #   @return [Discorb::User] The user who performed the action.
+
+      # @!visibility private
+      @events = {
+        1 => :guild_update,
+        10 => :channel_create,
+        11 => :channel_update,
+        12 => :channel_delete,
+        13 => :channel_overwrite_create,
+        14 => :channel_overwrite_update,
+        15 => :channel_overwrite_delete,
+        20 => :member_kick,
+        21 => :member_prune,
+        22 => :member_ban_add,
+        23 => :member_ban_remove,
+        24 => :member_update,
+        25 => :member_role_update,
+        26 => :member_move,
+        27 => :member_disconnect,
+        28 => :bot_add,
+        30 => :role_create,
+        31 => :role_update,
+        32 => :role_delete,
+        40 => :invite_create,
+        41 => :invite_update,
+        42 => :invite_delete,
+        50 => :webhook_create,
+        51 => :webhook_update,
+        52 => :webhook_delete,
+        60 => :emoji_create,
+        61 => :emoji_update,
+        62 => :emoji_delete,
+        72 => :message_delete,
+        73 => :message_bulk_delete,
+        74 => :message_pin,
+        75 => :message_unpin,
+        80 => :integration_create,
+        81 => :integration_update,
+        82 => :integration_delete,
+        83 => :stage_instance_create,
+        84 => :stage_instance_update,
+        85 => :stage_instance_delete,
+        90 => :sticker_create,
+        91 => :sticker_update,
+        92 => :sticker_delete,
+        110 => :thread_create,
+        111 => :thread_update,
+        112 => :thread_delete
+      }.freeze
+
+      # @!visibility private
+      @converts = {
+        channel: ->(client, id, _guild_id) { client.channels[id] },
+        thread: ->(client, id, _guild_id) { client.channels[id] },
+        role: ->(client, id, guild_id) { client.guilds[guild_id]&.roles&.[](id) },
+        member: ->(client, id, guild_id) { client.guilds[guild_id]&.members&.[](id) },
+        guild: ->(client, id, _guild_id) { client.guilds[id] },
+        message: ->(client, id, _guild_id) { client.messages[id] }
+      }
+
+      # @!visibility private
+      def initialize(client, data, guild_id)
+        @client = client
+        @guild_id = Snowflake.new(guild_id)
+        @id = Snowflake.new(data[:id])
+        @user_id = Snowflake.new(data[:user_id])
+        @target_id = Snowflake.new(data[:target_id])
+        @type = self.class.events[data[:action_type]]
+        @target = self.class.converts[@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')
+            define_singleton_method(option.to_s.sub('_id', '')) do
+              self.class.converts[option.to_s.split('_')[0].to_sym]&.call(client, value, @guild_id)
+            end
+          end
+        end
+        @options = data[:options] || {}
+      end
+
+      def user
+        @client.users[@user_id]
+      end
+
+      #
+      # Get a change with the given key.
+      #
+      # @param [Symbol] key The key to get.
+      #
+      # @return [Discorb::AuditLog::Entry::Change] The change with the given key.
+      # @return [nil] The change with the given key does not exist.
+      #
+      def [](key)
+        @changes[key]
+      end
+
+      def inspect
+        "#<#{self.class} #{@changes&.data&.length || 'No'} changes>"
+      end
+
+      class << self
+        attr_reader :events, :converts
+      end
+
+      #
+      # Represents the changes in an audit log entry.
+      #
+      class Changes < DiscordModel
+        attr_reader :data
+
+        #
+        # @!visibility private
+        #
+        def initialize(data)
+          @data = data.map { |d| [d[:key].to_sym, d] }.to_h
+          @data.each do |k, v|
+            define_singleton_method(k) { Change.new(v) }
+          end
+        end
+
+        def inspect
+          "#<#{self.class} #{@data.length} changes>"
+        end
+
+        #
+        # Get keys of changes.
+        #
+        # @return [Array<Symbol>] The keys of the changes.
+        #
+        def keys
+          @data.keys
+        end
+
+        #
+        # Get a change with the given key.
+        #
+        # @param [Symbol] key The key to get.
+        #
+        # @return [Discorb::AuditLog::Entry::Change] The change with the given key.
+        # @return [nil] The change with the given key does not exist.
+        #
+        def [](key)
+          @data[key.to_sym]
+        end
+      end
+
+      #
+      # Represents a change in an audit log entry.
+      # @note This instance will try to call a method of {#new_value} if the method wasn't defined.
+      #
+      class Change < DiscordModel
+        # @return [Symbol] The key of the change.
+        attr_reader :key
+        # @return [Object] The old value of the change.
+        attr_reader :old_value
+        # @return [Object] The new value of the change.
+        attr_reader :new_value
+
+        # @!visibility private
+        def initialize(data)
+          @key = data[:key].to_sym
+          method = case @key.to_s
+                   when /.*_id$/, 'id'
+                     ->(v) { Snowflake.new(v) }
+                   when 'permissions'
+                     ->(v) { Discorb::Permission.new(v.to_i) }
+                   else
+                     ->(v) { v }
+                   end
+          @old_value = data[:old_value].then(&method)
+          @new_value = data[:new_value].then(&method)
+        end
+
+        def method_missing(method, ...)
+          @new_value.__send__(method, ...)
+        end
+
+        def inspect
+          "#<#{self.class} #{@key.inspect} #{@old_value.inspect} -> #{@new_value.inspect}>"
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          @new_value.respond_to?(method, include_private)
+        end
+      end
+    end
+
+    #
+    # Represents an integration in an audit log entry.
+    #
+    class Integration < DiscordModel
+      # @return [Discorb::Snowflake] The ID of the integration.
+      attr_reader :id
+      # @return [Symbol] The type of the integration.
+      attr_reader :type
+      # @return [String] The name of the integration.
+      attr_reader :name
+      # @return [Discorb::Integration::Account] The account of the integration.
+      attr_reader :account
+
+      # @!visibility private
+      def initialize(data)
+        @id = Snowflake.new(data[:id])
+        @type = data[:type].to_sym
+        @name = data[:name]
+        @data = data
+        @account = Discorb::Integration::Account.new(@data[:account]) if @data[:account]
+      end
+
+      def inspect
+        "#<#{self.class} #{@id}>"
+      end
+    end
+  end
+end