discorb 0.0.1

data/lib/discorb/modules.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Module for sending and reading messages.
+  #
+  module Messageable
+    #
+    # Post a message to the channel.
+    #
+    # @param [String] content The message content.
+    # @param [Boolean] tts Whether the message is tts.
+    # @param [Discorb::Embed] embed The embed to send.
+    # @param [Array<Discorb::Embed>] embeds The embeds to send.
+    # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions.
+    # @param [Discorb::Message, Discorb::Message::Reference] reference The message to reply to.
+    # @param [Array<Discorb::Components>, Array<Array<Discorb::Components>>] components The components to send.
+    # @param [Discorb::File] file The file to send.
+    # @param [Array<Discorb::File>] files The files to send.
+    #
+    # @return [Discorb::Message] The message sent.
+    #
+    def post(content = nil, tts: false, embed: nil, embeds: nil, allowed_mentions: nil,
+                            reference: nil, components: nil, file: nil, files: nil)
+      Async do |_task|
+        payload = {}
+        payload[:content] = content if content
+        payload[:tts] = tts
+        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
+        payload[:message_reference] = reference.to_reference if reference
+        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[:components] = tmp_components.filter { |c| c.length.positive? }.map { |c| { type: 1, components: c.map(&:to_hash) } }
+        end
+        files = [file] if file
+        if files
+          headers, payload = Internet.multipart(payload, files)
+        else
+          headers = {}
+        end
+        _resp, data = @client.internet.post("#{base_url.wait}/messages", payload, headers: headers).wait
+        Message.new(@client, data.merge({ guild_id: @guild_id.to_s }))
+      end
+    end
+
+    #
+    # Fetch a message from ID.
+    #
+    # @param [Discorb::Snowflake] id The ID of the message.
+    #
+    # @return [Discorb::Message] The message.
+    # @raise [Discorb::NotFoundError] If the message is not found.
+    #
+    def fetch_message(id)
+      Async do
+        _resp, data = @client.internet.get("#{base_url.wait}/messages/#{id}").wait
+        Message.new(@client, data.merge({ guild_id: @guild_id.to_s }))
+      end
+    end
+
+    #
+    # Fetch a message history.
+    #
+    # @param [Integer] limit The number of messages to fetch.
+    # @param [Discorb::Snowflake] before The ID of the message to fetch before.
+    # @param [Discorb::Snowflake] after The ID of the message to fetch after.
+    # @param [Discorb::Snowflake] around The ID of the message to fetch around.
+    #
+    # @return [Array<Discorb::Message>] The messages.
+    #
+    def fetch_messages(limit = 50, before: nil, after: nil, around: nil)
+      Async do
+        params = {
+          limit: limit,
+          before: Discorb::Utils.try(after, :id),
+          after: Discorb::Utils.try(around, :id),
+          around: Discorb::Utils.try(before, :id),
+        }.filter { |_k, v| !v.nil? }.to_h
+        _resp, messages = @client.internet.get("#{base_url.wait}/messages?#{URI.encode_www_form(params)}").wait
+        messages.map { |m| Message.new(@client, m.merge({ guild_id: @guild_id.to_s })) }
+      end
+    end
+
+    #
+    # Trigger the typing indicator in the channel.
+    # @macro async
+    # @macro http
+    #
+    # If block is given, trigger typing indicator during executing block.
+    # @example
+    #   channel.typing do
+    #     channel.post("Waiting for 60 seconds...")
+    #     sleep 60
+    #     channel.post("Done!")
+    #   end
+    #
+    def typing
+      Async do |task|
+        if block_given?
+          begin
+            post_task = task.async do
+              @client.internet.post("/channels/#{@id}/typing", {})
+              sleep(5)
+            end
+            yield
+          ensure
+            post_task.stop
+          end
+        else
+          @client.internet.post("/channels/#{@id}/typing", {})
+        end
+      end
+    end
+  end
+end

data/lib/discorb/permission.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a permission per guild.
+  # ## Flag fields
+  # |`1 << 0`|`:create_instant_invite`|
+  # |`1 << 1`|`:kick_members`|
+  # |`1 << 2`|`:ban_members`|
+  # |`1 << 3`|`:administrator`|
+  # |`1 << 4`|`:manage_channels`|
+  # |`1 << 5`|`:manage_guild`|
+  # |`1 << 6`|`:add_reactions`|
+  # |`1 << 7`|`:view_audit_log`|
+  # |`1 << 8`|`:priority_speaker`|
+  # |`1 << 9`|`:stream`|
+  # |`1 << 10`|`:view_channel`|
+  # |`1 << 11`|`:send_messages`|
+  # |`1 << 12`|`:send_tts_messages`|
+  # |`1 << 13`|`:manage_messages`|
+  # |`1 << 14`|`:embed_links`|
+  # |`1 << 15`|`:attach_files`|
+  # |`1 << 16`|`:read_message_history`|
+  # |`1 << 17`|`:mention_everyone`|
+  # |`1 << 18`|`:use_external_emojis`|
+  # |`1 << 19`|`:view_guild_insights`|
+  # |`1 << 20`|`:connect`|
+  # |`1 << 21`|`:speak`|
+  # |`1 << 22`|`:mute_members`|
+  # |`1 << 23`|`:deafen_members`|
+  # |`1 << 24`|`:move_members`|
+  # |`1 << 25`|`:use_vad`|
+  # |`1 << 26`|`:change_nickname`|
+  # |`1 << 27`|`:manage_nicknames`|
+  # |`1 << 28`|`:manage_roles`|
+  # |`1 << 29`|`:manage_webhooks`|
+  # |`1 << 30`|`:manage_emojis`|
+  # |`1 << 31`|`:use_slash_commands`|
+  # |`1 << 32`|`:request_to_speak`|
+  # |`1 << 34`|`:manage_threads`|
+  # |`1 << 35`|`:use_public_threads`|
+  # |`1 << 36`|`:use_private_threads`|
+  #
+  class Permission < Flag
+    @bits = {
+      create_instant_invite: 0,
+      kick_members: 1,
+      ban_members: 2,
+      administrator: 3,
+      manage_channels: 4,
+      manage_guild: 5,
+      add_reactions: 6,
+      view_audit_log: 7,
+      priority_speaker: 8,
+      stream: 9,
+      view_channel: 10,
+      send_messages: 11,
+      send_tts_messages: 12,
+      manage_messages: 13,
+      embed_links: 14,
+      attach_files: 15,
+      read_message_history: 16,
+      mention_everyone: 17,
+      use_external_emojis: 18,
+      view_guild_insights: 19,
+      connect: 20,
+      speak: 21,
+      mute_members: 22,
+      deafen_members: 23,
+      move_members: 24,
+      use_vad: 25,
+      change_nickname: 26,
+      manage_nicknames: 27,
+      manage_roles: 28,
+      manage_webhooks: 29,
+      manage_emojis: 30,
+      use_slash_commands: 31,
+      request_to_speak: 32,
+      manage_threads: 34,
+      use_public_threads: 35,
+      use_private_threads: 36,
+    }.freeze
+  end
+
+  #
+  # Represents a permission per channel.
+  #
+  class PermissionOverwrite
+    # @!attribute [r] allow
+    #   @return [Discorb::Permission] The allowed permissions.
+    # @!attribute [r] deny
+    #   @return [Discorb::Permission] The denied permissions.
+    # @!attribute [r] allow_value
+    #   @return [Integer] The allowed permissions as an integer.
+    # @!attribute [r] deny_value
+    #   @return [Integer] The denied permissions as an integer.
+
+    @raw_bits = {
+      create_instant_invite: 0,
+      kick_members: 1,
+      ban_members: 2,
+      administrator: 3,
+      manage_channels: 4,
+      manage_guild: 5,
+      add_reactions: 6,
+      view_audit_log: 7,
+      priority_speaker: 8,
+      stream: 9,
+      view_channel: 10,
+      send_messages: 11,
+      send_tts_messages: 12,
+      manage_messages: 13,
+      embed_links: 14,
+      attach_files: 15,
+      read_message_history: 16,
+      mention_everyone: 17,
+      use_external_emojis: 18,
+      view_guild_insights: 19,
+      connect: 20,
+      speak: 21,
+      mute_members: 22,
+      deafen_members: 23,
+      move_members: 24,
+      use_vad: 25,
+      change_nickname: 26,
+      manage_nicknames: 27,
+      manage_roles: 28,
+      manage_webhooks: 29,
+      manage_emojis: 30,
+      use_slash_commands: 31,
+      request_to_speak: 32,
+      manage_threads: 34,
+      use_public_threads: 35,
+      use_private_threads: 36,
+    }.freeze
+    @bits = @raw_bits.transform_values { |v| 1 << v }.freeze
+
+    # @!visibility private
+    def initialize(allow, deny)
+      @allow = allow
+      @deny = deny
+    end
+
+    def allow
+      self.class.bits.keys.filter { |field| @allow & self.class.bits[field] != 0 }
+    end
+
+    alias +@ allow
+
+    def deny
+      self.class.bits.keys.filter { |field| @deny & self.class.bits[field] != 0 }
+    end
+
+    alias -@ deny
+
+    def allow_value
+      @allow
+    end
+
+    def deny_value
+      @deny
+    end
+
+    #
+    # Converts the permission overwrite to a hash.
+    #
+    # @return [Hash] The permission overwrite as a hash.
+    #
+    def to_hash
+      self.class.bits.keys.map do |field|
+        [field, if @allow & self.class.bits[field] != 0
+          true
+        elsif @deny & self.class.bits[method] != 0
+          false
+        end]
+      end.to_h
+    end
+
+    #
+    # Union of the permission overwrites.
+    #
+    # @param [Discorb::PermissionOverwrite] other The other permission overwrite.
+    #
+    # @return [Discorb::PermissionOverwrite] The union of the permission overwrites.
+    #
+    def +(other)
+      result = to_hash
+      self.class.bits.each_key do |field|
+        result[field] = other[field] unless other[field].nil?
+      end
+      self.class.from_hash(result)
+    end
+
+    #
+    # Returns whether overwrite of the given field.
+    #
+    # @param [Symbol] field The field to check.
+    #
+    # @return [true, false, nil] Whether the field is allowed, denied or not set.
+    #
+    def [](field)
+      if @allow & self.class.bits[field] != 0
+        true
+      elsif @deny & self.class.bits[field] != 0
+        false
+      end
+    end
+
+    #
+    # Sets the given field to the given value.
+    #
+    # @param [Symbol] key The field to set.
+    # @param [Boolean] bool The value to set.
+    #
+    def []=(key, bool)
+      case bool
+      when true
+        @allow |= self.class.bits[key]
+        @deny &= ~self.class.bits[key]
+      when false
+        @allow &= ~self.class.bits[key]
+        @deny |= self.class.bits[key]
+      else
+        @allow &= ~self.class.bits[key]
+        @deny &= ~self.class.bits[key]
+      end
+    end
+
+    def method_missing(method, bool = nil)
+      if self.class.bits.key?(method)
+        self[method]
+      elsif self.class.bits.key?(method.to_s.delete_suffix("=").to_sym)
+        key = method.to_s.delete_suffix("=").to_sym
+        self[key] = bool
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, _arg)
+      self.class.bits.key?(method.to_s.delete_suffix("=").to_sym) ? true : super
+    end
+
+    class << self
+      # @!visibility private
+      attr_reader :bits
+
+      #
+      # Initializes a permission overwrite from a hash.
+      #
+      # @param [Hash] hash The hash to initialize the permission overwrite from.
+      #
+      # @return [Discorb::PermissionOverwrite] The permission overwrite.
+      #
+      def from_hash(hash)
+        allow = 0
+        deny = 0
+        hash.filter { |k, v| self.class.bits.keys.include?(k) && [true, false].include?(v) }.each do |k, v|
+          if v
+            allow += self.class.bits[k]
+          else
+            deny += self.class.bits[k]
+          end
+        end
+
+        new(allow, deny)
+      end
+    end
+  end
+end

data/lib/discorb/presence.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a presence of user.
+  #
+  class Presence < DiscordModel
+    # @return [:online, :idle, :dnd, :offline] The status of the user.
+    attr_reader :status
+    # @return [Array<Discorb::Presence::Activity>] The activities of the user.
+    attr_reader :activities
+    # @return [Discorb::Presence::ClientStatus] The client status of the user.
+    attr_reader :client_status
+
+    # @!attribute [r] user
+    #   @return [Discorb::User] The user of the presence.
+    # @!attribute [r] guild
+    #   @return [Discorb::Guild] The guild of the presence.
+    # @!attribute [r] activity
+    #   @return [Discorb::Presence::Activity] The activity of the presence.
+
+    # @!visibility private
+    def initialize(client, data)
+      @client = client
+      @data = data
+      _set_data(data)
+    end
+
+    def user
+      @client.users[@user_id]
+    end
+
+    def guild
+      @client.guilds[@guild_id]
+    end
+
+    def activity
+      @activities[0]
+    end
+
+    def inspect
+      "#<#{self.class} @status=#{@status.inspect} @activity=#{activity.inspect}>"
+    end
+
+    #
+    # Represents an activity of a user.
+    #
+    class Activity < DiscordModel
+      # @return [String] The name of the activity.
+      attr_reader :name
+      # @return [:game, :streaming, :listening, :watching, :custom, :competing] The type of the activity.
+      attr_reader :type
+      # @return [String] The url of the activity.
+      attr_reader :url
+      # @return [Time] The time the activity was created.
+      attr_reader :created_at
+      alias started_at created_at
+      # @return [Discorb::Presence::Activity::Timestamps] The timestamps of the activity.
+      attr_reader :timestamps
+      # @return [Discorb::Snowflake] The application id of the activity.
+      attr_reader :application_id
+      # @return [String] The details of the activity.
+      attr_reader :details
+      # @return [String] The state of party.
+      attr_reader :state
+      # @return [Discorb::Emoji] The emoji of the activity.
+      attr_reader :emoji
+      # @return [Discorb::Presence::Activity::Party] The party of the activity.
+      # @return [nil] If the activity is not a party activity.
+      attr_reader :party
+      # @return [Discorb::Presence::Activity::Asset] The assets of the activity.
+      # @return [nil] If the activity has no assets.
+      attr_reader :assets
+      # @return [Discorb::StageInstance] The instance of the activity.
+      # @return [nil] If the activity is not a stage activity.
+      attr_reader :instance
+      # @return [Array<Discorb::Presence::Activity::Button>] The buttons of the activity.
+      # @return [nil] If the activity has no buttons.
+      attr_reader :buttons
+      # @return [Discorb::Presence::Activity::Flag] The flags of the activity.
+      attr_reader :flags
+
+      @activity_types = {
+        0 => :game,
+        1 => :streaming,
+        2 => :listening,
+        3 => :watching,
+        4 => :custom,
+        5 => :competing,
+      }
+
+      # @!visibility private
+      def initialize(data)
+        @name = data[:name]
+        @type = self.class.activity_types[data[:type]]
+        @url = data[:url]
+        @created_at = Time.at(data[:created_at])
+        @timestamps = data[:timestamps] && Timestamps.new(data[:timestamps])
+        @application_id = data[:application_id] && Snowflake.new(data[:application_id])
+        @details = data[:details]
+        @state = data[:state]
+        @emoji = if data[:emoji]
+            data[:emoji][:id].nil? ? UnicodeEmoji.new(data[:emoji][:name]) : PartialEmoji.new(data[:emoji])
+          end
+        @party = data[:party] && Party.new(data[:party])
+        @assets = data[:assets] && Asset.new(data[:assets])
+        @instance = data[:instance]
+        @buttons = data[:buttons] && data[:buttons].map { |b| Button.new(b) }
+        @flags = data[:flags] && Flag.new(data[:flags])
+      end
+
+      #
+      # Convert the activity to a string.
+      #
+      # @return [String] The string representation of the activity.
+      #
+      def to_s
+        case @type
+        when :game
+          "Playing #{@name}"
+        when :streaming
+          "Streaming #{@details}"
+        when :listening
+          "Listening to #{@name}"
+        when :watching
+          "Watching #{@name}"
+        when :custom
+          "#{@emoji} #{@state}"
+        when :competing
+          "Competing in #{@name}"
+        end
+      end
+
+      #
+      # Represents the timestamps of an activity.
+      #
+      class Timestamps < DiscordModel
+        # @return [Time] The start time of the activity.
+        attr_reader :start
+        # @return [Time] The end time of the activity.
+        attr_reader :end
+
+        # @!visibility private
+        def initialize(data)
+          @start = data[:start] && Time.at(data[:start])
+          @end = data[:end] && Time.at(data[:end])
+        end
+      end
+
+      class Party < DiscordModel
+        # @return [String] The id of the party.
+        attr_reader :id
+
+        # @!attribute [r] current_size
+        #   @return [Integer] The current size of the party.
+        # @!attribute [r] max_size
+        #   @return [Integer] The max size of the party.
+
+        # @!visibility private
+        def initialize(data)
+          @id = data[:id]
+          @size = data[:size]
+        end
+
+        def current_size
+          @size[0]
+        end
+
+        def max_size
+          @size[1]
+        end
+      end
+
+      #
+      # Represents the assets of an activity.
+      #
+      class Asset < DiscordModel
+        # @return [String] The large image ID of the asset.
+        attr_reader :large_image
+        alias large_id large_image
+        # @return [String] The large text of the activity.
+        attr_reader :large_text
+        # @return [String] The small image ID of the activity.
+        attr_reader :small_image
+        alias small_id small_image
+        # @return [String] The small text of the activity.
+        attr_reader :small_text
+
+        def initialize(data)
+          @large_image = data[:large_image]
+          @large_text = data[:large_text]
+          @small_image = data[:small_image]
+          @small_text = data[:small_text]
+        end
+      end
+
+      #
+      # Represents the flags of an activity.
+      # ## Flag fields
+      # |`1 << 0`|`:instance`|
+      # |`1 << 1`|`:join`|
+      # |`1 << 2`|`:spectate`|
+      # |`1 << 3`|`:join_request`|
+      # |`1 << 4`|`:sync`|
+      # |`1 << 5`|`:play`|
+      #
+      class Flag < Discorb::Flag
+        @bits = {
+          instance: 0,
+          join: 1,
+          spectate: 2,
+          join_request: 3,
+          sync: 4,
+          play: 5,
+        }
+      end
+
+      #
+      # Represents a secrets of an activity.
+      #
+      class Secrets < DiscordModel
+        # @return [String] The join secret of the activity.
+        attr_reader :join
+        # @return [String] The spectate secret of the activity.
+        attr_reader :spectate
+        # @return [String] The match secret of the activity.
+        attr_reader :match
+
+        # @!visibility private
+        def initialize(data)
+          @join = data[:join]
+          @spectate = data[:spectate]
+          @match = data[:match]
+        end
+      end
+
+      #
+      # Represents a button of an activity.
+      #
+      class Button < DiscordModel
+        # @return [String] The text of the button.
+        attr_reader :label
+        # @return [String] The URL of the button.
+        attr_reader :url
+        alias text label
+
+        # @!visibility private
+        def initialize(data)
+          @label = data[0]
+          @url = data[1]
+        end
+      end
+
+      class << self
+        # @!visibility private
+        attr_reader :activity_types
+      end
+    end
+
+    #
+    # Represents a user's client status.
+    #
+    class ClientStatus < DiscordModel
+      # @return [Symbol] The desktop status of the user.
+      attr_reader :desktop
+      # @return [Symbol] The mobile status of the user.
+      attr_reader :mobile
+      # @return [Symbol] The web status of the user.
+      attr_reader :web
+
+      # @!attribute [r] desktop?
+      #   @return [Boolean] Whether the user is not offline on desktop.
+      # @!attribute [r] mobile?
+      #   @return [Boolean] Whether the user is not offline on mobile.
+      # @!attribute [r] web?
+      #   @return [Boolean] Whether the user is not offline on web.
+
+      # @!visibility private
+      def initialize(data)
+        @desktop = data[:desktop]&.to_sym || :offline
+        @mobile = data[:mobile]&.to_sym || :offline
+        @web = data[:web]&.to_sym || :offline
+      end
+
+      def desktop?
+        @desktop != :offline
+      end
+
+      def mobile?
+        @mobile != :offline
+      end
+
+      def web?
+        @web != :offline
+      end
+    end
+
+    private
+
+    def _set_data(data)
+      @user_id = data[:user][:id]
+      @guild_id = data[:guild_id]
+      @status = data[:status].to_sym
+      @activities = data[:activities].map { |a| Activity.new(a) }
+      @client_status = ClientStatus.new(data[:client_status])
+    end
+  end
+end