rubord 0.1.3

data/lib/rubord/models/flags.rb

@@ -0,0 +1,249 @@
+module Rubord
+  module Permissions
+    FLAGS = {
+      create_instant_invite: 1 << 0,
+      kick_members: 1 << 1,
+      ban_members: 1 << 2,
+      administrator: 1 << 3,
+      manage_channels: 1 << 4,
+      manage_guild: 1 << 5,
+      add_reactions: 1 << 6,
+      view_audit_log: 1 << 7,
+      priority_speaker: 1 << 8,
+      stream: 1 << 9,
+      view_channel: 1 << 10,
+      send_messages: 1 << 11,
+      send_tts_messages: 1 << 12,
+      manage_messages: 1 << 13,
+      embed_links: 1 << 14,
+      attach_files: 1 << 15,
+      read_message_history: 1 << 16,
+      mention_everyone: 1 << 17,
+      use_external_emojis: 1 << 18,
+      view_guild_insights: 1 << 19,
+      connect: 1 << 20,
+      speak: 1 << 21,
+      mute_members: 1 << 22,
+      deafen_members: 1 << 23,
+      move_members: 1 << 24,
+      use_vad: 1 << 25,
+      change_nickname: 1 << 26,
+      manage_nicknames: 1 << 27,
+      manage_roles: 1 << 28,
+      manage_webhooks: 1 << 29,
+      manage_emojis_and_stickers: 1 << 30,
+      use_application_commands: 1 << 31,
+      manage_events: 1 << 32,
+      moderate_members: 1 << 40,
+    }.freeze
+
+    ALL = FLAGS.values.reduce(0, :|)
+
+    def self.combine(*perms)
+      perms.map { |p| FLAGS[p] }.compact.reduce(0, :|)
+    end
+  end
+
+  module Intents
+    FLAGS = {
+      guilds: 1 << 0,
+      guild_members: 1 << 1,
+      guild_bans: 1 << 2,
+      guild_emojis: 1 << 3,
+      guild_integrations: 1 << 4,
+      guild_webhooks: 1 << 5,
+      guild_invites: 1 << 6,
+      guild_voice_states: 1 << 7,
+      guild_presences: 1 << 8,
+      guild_messages: 1 << 9,
+      guild_message_reactions: 1 << 10,
+      guild_message_typing: 1 << 11,
+      direct_messages: 1 << 12,
+      direct_message_reactions: 1 << 13,
+      direct_message_typing: 1 << 14,
+      message_content: 1 << 15,
+      guild_scheduled_events: 1 << 16,
+      auto_moderation_configuration: 1 << 20,
+      auto_moderation_execution: 1 << 21,
+    }.freeze
+
+    class << self
+      def [](intent_name)
+        FLAGS[intent_name.to_sym] if intent_name
+      end
+
+      def all = FLAGS.values.reduce(0, :|)
+
+      def exists?(intent_name)
+        FLAGS.key?(intent_name.to_sym)
+      end
+
+      def names
+        FLAGS.keys
+      end
+
+      def values
+        FLAGS.values
+      end
+
+      def combine(*intents)
+        intents.flatten.reduce(0) do |sum, intent|
+          case intent
+          when Integer
+            sum | intent
+          when Symbol, String
+            value = FLAGS[intent.to_sym]
+            unless value
+              Rubord::Logger.warn "[Rubord:Intents] Unknown intent: #{intent.inspect}"
+              next sum
+            end
+            sum | value
+          else
+            Rubord::Logger.warn "[Rubord:Intents] Invalid intent type: #{intent.class}"
+            sum
+          end
+        end
+      end
+
+      def guilds
+        FLAGS[:guilds]
+      end
+
+      def guild_members
+        FLAGS[:guild_members]
+      end
+
+      def guild_bans
+        FLAGS[:guild_bans]
+      end
+
+      def guild_emojis
+        FLAGS[:guild_emojis]
+      end
+
+      def guild_integrations
+        FLAGS[:guild_integrations]
+      end
+
+      def guild_webhooks
+        FLAGS[:guild_webhooks]
+      end
+
+      def guild_invites
+        FLAGS[:guild_invites]
+      end
+
+      def guild_voice_states
+        FLAGS[:guild_voice_states]
+      end
+
+      def guild_presences
+        FLAGS[:guild_presences]
+      end
+
+      def guild_messages
+        FLAGS[:guild_messages]
+      end
+
+      def guild_message_reactions
+        FLAGS[:guild_message_reactions]
+      end
+
+      def guild_message_typing
+        FLAGS[:guild_message_typing]
+      end
+
+      def direct_messages
+        FLAGS[:direct_messages]
+      end
+
+      def direct_message_reactions
+        FLAGS[:direct_message_reactions]
+      end
+
+      def direct_message_typing
+        FLAGS[:direct_message_typing]
+      end
+
+      def message_content
+        FLAGS[:message_content]
+      end
+
+      def guild_scheduled_events
+        FLAGS[:guild_scheduled_events]
+      end
+
+      def auto_moderation_configuration
+        FLAGS[:auto_moderation_configuration]
+      end
+
+      def auto_moderation_execution
+        FLAGS[:auto_moderation_execution]
+      end
+
+      def default
+        combine(
+          :guilds,
+          :guild_members,
+          :guild_messages,
+          :guild_message_reactions,
+          :direct_messages,
+          :direct_message_reactions
+        )
+      end
+
+      def privileged
+        combine(
+          :guild_members,
+          :guild_presences,
+          :message_content
+        )
+      end
+
+      def include?(intent_value, intent_name)
+        intent_value & self[intent_name] != 0
+      end
+
+      def method_missing(name, *args)
+        if FLAGS.key?(name)
+          FLAGS[name]
+        elsif name.to_s.end_with?("?") && FLAGS.key?(name.to_s[0...-1].to_sym)
+          intent_name = name.to_s[0...-1].to_sym
+          if args.first.is_a?(Integer)
+            args.first & FLAGS[intent_name] != 0
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        FLAGS.key?(name) ||
+        (name.to_s.end_with?("?") && FLAGS.key?(name.to_s[0...-1].to_sym)) ||
+        super
+      end
+    end
+  end
+
+  module MessageFlags
+    FLAGS = {
+      crossposted: 1 << 0,
+      is_crosspost: 1 << 1,
+      suppress_embeds: 1 << 2,
+      source_message_deleted: 1 << 3,
+      urgent: 1 << 4,
+      ephemeral: 1 << 6,
+      loading: 1 << 7,
+      components_v2: 1 << 15,
+    }.freeze
+
+    def self.combine(*flags)
+      flags.map { |f| FLAGS[f] }.compact.reduce(0, :|)
+    end
+
+    EPHEMERAL = FLAGS[:ephemeral]
+    COMPONENTS_V2 = FLAGS[:components_v2]
+  end
+end

data/lib/rubord/models/guild.rb

@@ -0,0 +1,78 @@
+module Rubord
+  class Guild
+    attr_reader :id,
+                :members,
+                :roles,
+                :client
+
+    def initialize(data, client)
+      @client   = client
+      @id       = data["id"]
+      @members  = Rubord::Collection.new
+      @roles    = Rubord::Collection.new
+      @owner    = data["owner"] || false
+      @owner_id = data["owner_id"]
+
+      client.guilds.set(@id, self)
+      load_roles(data["roles"]) if data["roles"]
+    end
+
+    def is_owner?(user_id)
+      @owner_id.to_i == user_id.to_i
+    end
+
+    def owner_id
+      @owner_id
+    end
+
+    def fetch_owner
+      return nil unless @owner_id
+      @client.users.get(@owner_id) ||
+        begin
+          data = @client.rest.get_user(@owner_id)
+          user = Rubord::User.new(data)
+          @client.users.set(user.id, user)
+          user
+        rescue Rubord::HTTPError
+          nil
+        end
+    end
+
+    def members_count
+      @members.size
+    end
+
+    def load_roles(raw_roles)
+      raw_roles.each do |role_data|
+        role = Rubord::Role.new(role_data)
+        @roles.set(role.id, role)
+      end
+    end
+
+    def add_member(data)
+      member = Rubord::Member.new(
+        data.merge("guild_id" => @id),
+        @client
+      )
+
+      @members.set(member.id, member)
+      member
+    end
+
+    def fetch_member(user_id)
+      cached = @members.get(user_id)
+      return cached if cached
+
+      data = @client.rest.get_guild_member(@id, user_id)
+      return nil unless data
+
+      add_member(data)
+    rescue Rubord::HTTPError
+      nil
+    end
+
+    def inspect
+      "#<Rubord::Guild id=#{@id} members=#{@members.size} roles=#{@roles.size}>"
+    end
+  end
+end

data/lib/rubord/models/interaction.rb

@@ -0,0 +1,136 @@
+module Rubord
+  class Interaction
+    TYPES = {
+      ping: 1,
+      application_command: 2,
+      message_component: 3,
+      modal_submit: 5
+    }
+  
+    COMPONENT_TYPES = {
+      button: 2,
+      select_menu: 3
+    }
+
+    attr_reader :id,
+                :application_id,
+                :type,
+                :data,
+                :guild_id,
+                :channel_id,
+                :member,
+                :user,
+                :token,
+                :version,
+                :message,
+                :client
+
+    def initialize(data, client)
+      @client         = client
+      @id             = data["id"]
+      @application_id = data["application_id"]
+      @type           = data["type"]
+      @data           = data["data"] || {}
+      @guild_id       = data["guild_id"]
+      @channel_id     = data["channel_id"]
+      @token          = data["token"]
+      @version        = data["version"]
+      @message        = if data["message"]
+                          Rubord::Message.new(data["message"], client)
+                        end
+
+      member_data             = data["member"]
+      member_data["guild_id"] = data["guild_id"]
+      @member                 = Rubord::Member.new(member_data, client)
+    end
+
+    def post(content = nil, embeds: nil, components: nil, flags: nil)
+      data = {}
+      data[:content] = content if content
+      data[:embeds] = Array(embeds).map(&:to_h) if embeds
+      data[:components] = Array(components).map(&:to_h) if components
+      data[:flags] = flags
+
+      client.rest.interactions_response(
+        @id,
+        @token,
+        type: 4,
+        data: data
+      )
+    end
+
+    def edit(content = nil, embeds: nil, components: nil, flags: nil)
+      client.rest.interaction_edit(
+        @application_id,
+        @token,
+        content: content,
+        embeds: embeds,
+        components: components,
+        flags: ephemeral ? 64 : nil
+      )
+    end
+
+    def defer(flags: nil)
+      data = {}
+      data[:flags] = flags
+
+      client.rest.interactions_response(
+        @id,
+        @token,
+        type: 5,
+        data: data
+      )
+    end
+
+    def deferUpdate
+      client.rest.interactions_response(
+        @id,
+        @token,
+        type: 6
+      )
+    end
+
+    def update(content = nil, embeds: nil, components: nil)
+      deferUpdate
+
+      client.rest.interaction_edit(
+        @application_id,
+        @token,
+        content: content,
+        embeds: embeds,
+        components: components
+      )
+    end
+
+    def followUp(content = nil, embeds: nil, components: nil, flags: nil)
+      client.rest.interaction_followup(
+        @application_id,
+        @token,
+        content: content,
+        embeds: embeds,
+        components: components,
+        flags: flags
+      )
+    end
+
+    def command?
+      @type == TYPES[:application_command]
+    end
+
+    def component?
+      @type == TYPES[:message_component]
+    end
+
+    def is_type?(type)
+      component? && @data["component_type"] == COMPONENT_TYPES[type.to_sym]
+    end
+
+    def custom_id
+      @data["custom_id"]
+    end
+
+    def inspect
+      "#<Rubord::Interaction id=#{@id} type=#{@type} guild_id=#{@guild_id} channel_id=#{@channel_id}>"
+    end
+  end
+end

data/lib/rubord/models/member.rb

@@ -0,0 +1,63 @@
+module Rubord
+  class Member
+    attr_reader :id,
+                :user,
+                :roles,
+                :guild_id,
+                :client
+
+    def initialize(data, client)
+      @client   = client
+      @guild_id = data["guild_id"]
+      @roles    = data["roles"] || []
+
+      @user = Rubord::User.new(data["user"])
+      @id   = @user.id
+
+      client.users.set(@id, @user)
+      guild&.members&.set(@id, self)
+    end
+
+    def guild
+      client.guilds.get(@guild_id)
+    end
+
+    def role_objects
+      return [] unless guild && guild.roles
+
+      @roles
+        .map { |role_id| guild.roles.get(role_id) }
+        .compact
+    end
+
+    def permissions
+      return [] unless guild && guild.roles
+
+      bitfield = 0
+
+      if (everyone = guild.roles.get(guild.id))
+        bitfield |= everyone.permissions
+      end
+
+      role_objects.each do |role|
+        bitfield |= role.permissions
+      end
+
+      if (bitfield & Rubord::Permissions::FLAGS[:administrator]) != 0
+        return Rubord::Permissions::FLAGS.keys
+      end
+
+      Rubord::Permissions::FLAGS
+        .select { |_name, flag| (bitfield & flag) != 0 }
+        .keys
+    end
+
+    def has_permission?(perm)
+      permissions.include?(perm.to_sym)
+    end
+
+    def inspect
+      "#<Rubord::Member id=#{@id} guild_id=#{@guild_id} roles=#{@roles}>"
+    end
+  end
+end

data/lib/rubord/models/mention.rb

@@ -0,0 +1,47 @@
+module Rubord
+  class Mention
+    attr_reader :users,
+                :roles,
+                :channels,
+                :everyone
+
+    def initialize(data, client, guild)
+      @everyone = data["mention_everyone"] || false
+
+      @users = (data["mentions"] || []).map do |user_data|
+        user = Rubord::User.new(user_data)
+        client.users.set(user.id, user)
+        user
+      end
+
+      @roles = (data["mention_roles"] || []).map do |role_id|
+        guild&.roles&.get(role_id)
+      end
+
+      @channels = 
+        if data["mention_channels"]
+          data["mention_channels"].map do |channel_data|
+            channel = Rubord::Channel.new(channel_data, client)
+            client.channels.set(channel.id, channel)
+            channel
+          end
+        else
+          Rubord.Parser.channel_mentions(data["content"] || "").map do |channel_id|
+            client.channels.get(channel_id) || Rubord::Channel.new({ "id" => channel_id }, client)
+          end
+        end
+    end
+
+    def mention_everyone?
+      @everyone
+    end
+
+    def empty?
+      users.empty? && roles.empty? && channels.empty? && !everyone
+    end
+
+    def inspect
+      "#<Rubord::Mention users=#{users.size} roles=#{roles.size} channels=#{channels.size} everyone=#{everyone}>"
+    end
+  end
+end

data/lib/rubord/models/message.rb

@@ -0,0 +1,88 @@
+module Rubord
+  class Message
+    attr_reader :id,
+                :content,
+                :author,
+                :channel_id,
+                :guild_id,
+                :channel,
+                :mentions
+
+    def initialize(data, client)
+      @client     = client
+      @id         = data["id"]
+      @content    = data["content"]
+      @channel_id = data["channel_id"]
+      @guild_id   = data["guild_id"]
+
+      @author = Rubord::User.new(data["author"])
+      client.users.set(@author.id, @author)
+
+      @channel =
+        client.channels.get(@channel_id) ||
+        Rubord::Channel.new({ "id" => @channel_id }, client)
+
+      @mentions = Rubord::Mention.new(
+        data,
+        client,
+        guild
+      )
+    end
+
+    def guild
+      return nil unless @guild_id
+
+      @guild ||=
+        @client.guilds.get(@guild_id) ||
+        Rubord::Guild.new(@client.rest.get_guild(@guild_id), @client)
+    end
+
+    def member
+      return nil unless guild
+      guild.fetch_member(@author.id)
+    end
+
+    def post(content = nil, embeds: nil, components: nil, flags: nil)
+      @client.rest.send_message(
+        @channel_id,
+        content: content,
+        embeds: embeds,
+        components: components,
+        flags: flags
+      )
+    end
+
+    def reply(content = nil, embeds: nil, components: nil, flags: nil)
+      @client.rest.reply_message(
+        @channel_id,
+        @id,
+        content: content,
+        embeds: embeds,
+        components: components,
+        flags: flags
+      )
+    end
+
+    def edit(content = nil, embeds: nil, components: nil, flags: nil)
+      @client.rest.edit_message(
+        @channel_id,
+        @id,
+        content: content,
+        embeds: embeds,
+        components: components,
+        flags: flags
+      )
+    end
+
+    def delete
+      @client.rest.delete_message(
+        @channel_id,
+        @id
+      )
+    end
+
+    def inspect
+      "#<Rubord::Message id=#{@id} mentions=#{mentions.inspect}>"
+    end
+  end
+end

data/lib/rubord/models/role.rb

@@ -0,0 +1,15 @@
+module Rubord
+  class Role
+    attr_reader :id,
+                :name,
+                :permissions,
+                :position
+
+    def initialize(data)
+      @id           = data["id"]
+      @name         = data["name"]
+      @permissions  = data["permissions"].to_i
+      @position     = data["position"]
+    end
+  end
+end

data/lib/rubord/models/user.rb

@@ -0,0 +1,21 @@
+module Rubord
+  class User
+    attr_reader :id,
+                :username,
+                :globalname,
+                :discriminator,
+                :creationDate,
+                :bot,
+                :tag
+
+    def initialize(data)
+      @id             = data["id"]
+      @username       = data["username"]
+      @globalname     = data["global_name"]
+      @discriminator  = data["discriminator"]
+      @creationDate   = ((@id.to_i >> 22) + 1420070400000) / 1000
+      @bot            = data["bot"] || false
+      @tag            = "#{@username}##{@discriminator}"
+    end
+  end
+end