rubycord 1.0.0

data/lib/rubycord/events/interactions.rb

@@ -0,0 +1,480 @@
+require "rubycord/events/generic"
+require "rubycord/data"
+
+module Rubycord::Events
+  # Generic subclass for interaction events
+  class InteractionCreateEvent < Event
+    # @return [Interaction] The interaction for this event.
+    attr_reader :interaction
+
+    # @!attribute [r] type
+    #   @return [Integer]
+    #   @see Interaction#type
+    # @!attribute [r] server
+    #   @return [Server, nil]
+    #   @see Interaction#server
+    # @!attribute [r] server_id
+    #   @return [Integer]
+    #   @see Interaction#server_id
+    # @!attribute [r] channel
+    #   @return [Channel]
+    #   @see Interaction#channel
+    # @!attribute [r] channel_id
+    #   @return [Integer]
+    #   @see Interaction#channel_id
+    # @!attribute [r] user
+    #   @return [User]
+    #   @see Interaction#user
+    delegate :type, :server, :server_id, :channel, :channel_id, :user, to: :interaction
+
+    def initialize(data, bot)
+      @interaction = Rubycord::Interaction.new(data, bot)
+      @bot = bot
+    end
+
+    # (see Interaction#respond)
+    def respond(content: nil, tts: nil, embeds: nil, allowed_mentions: nil, flags: 0, ephemeral: nil, wait: false, components: nil, &)
+      @interaction.respond(
+        content: content, tts: tts, embeds: embeds, allowed_mentions: allowed_mentions,
+        flags: flags, ephemeral: ephemeral, wait: wait, components: components, &
+      )
+    end
+
+    # (see Interaction#defer)
+    def defer(flags: 0, ephemeral: true)
+      @interaction.defer(flags: flags, ephemeral: ephemeral)
+    end
+
+    # (see Interaction#update_message)
+    def update_message(content: nil, tts: nil, embeds: nil, allowed_mentions: nil, flags: 0, ephemeral: nil, wait: false, components: nil, &)
+      @interaction.update_message(
+        content: content, tts: tts, embeds: embeds, allowed_mentions: allowed_mentions,
+        flags: flags, ephemeral: ephemeral, wait: wait, components: components, &
+      )
+    end
+
+    # (see Interaction#show_modal)
+    def show_modal(title:, custom_id:, components: nil, &)
+      @interaction.show_modal(title: title, custom_id: custom_id, components: components, &)
+    end
+
+    # (see Interaction#edit_response)
+    def edit_response(content: nil, embeds: nil, allowed_mentions: nil, components: nil, &)
+      @interaction.edit_response(content: content, embeds: embeds, allowed_mentions: allowed_mentions, components: components, &)
+    end
+
+    # (see Interaction#delete_response)
+    def delete_response
+      @interaction.delete_response
+    end
+
+    # (see Interaction#send_message)
+    def send_message(content: nil, embeds: nil, tts: false, allowed_mentions: nil, flags: 0, ephemeral: nil, components: nil, &)
+      @interaction.send_message(content: content, embeds: embeds, tts: tts, allowed_mentions: allowed_mentions, flags: flags, ephemeral: ephemeral, components: components, &)
+    end
+
+    # (see Interaction#edit_message)
+    def edit_message(message, content: nil, embeds: nil, allowed_mentions: nil, &)
+      @interaction.edit_message(message, content: content, embeds: embeds, allowed_mentions: allowed_mentions, &)
+    end
+
+    # (see Interaction#delete_message)
+    def delete_message(message)
+      @interaction.delete_message(message)
+    end
+
+    # (see Interaction#defer_update)
+    def defer_update
+      @interaction.defer_update
+    end
+
+    # (see Interaction#get_component)
+    def get_component(custom_id)
+      @interaction.get_component(custom_id)
+    end
+  end
+
+  # Event handler for INTERACTION_CREATE events.
+  class InteractionCreateEventHandler < EventHandler
+    # @!visibility private
+    def matches?(event)
+      return false unless event.is_a? InteractionCreateEvent
+
+      [
+        matches_all(@attributes[:type], event.type) do |a, e|
+          a == case a
+          when String, Symbol
+            Rubycord::Interactions::TYPES[e.to_sym]
+          else
+            e
+          end
+        end,
+
+        matches_all(@attributes[:server], event.interaction) do |a, e|
+          a.resolve_id == e.server_id
+        end,
+
+        matches_all(@attributes[:channel], event.interaction) do |a, e|
+          a.resolve_id == e.channel_id
+        end,
+
+        matches_all(@attributes[:user], event.user) do |a, e|
+          a.resolve_id == e.id
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Event for ApplicationCommand interactions.
+  class ApplicationCommandEvent < InteractionCreateEvent
+    # Struct to allow accessing data via [] or methods.
+    Resolved = Struct.new("Resolved", :channels, :members, :messages, :roles, :users, :attachments)
+
+    # @return [String] The name of the command.
+    attr_reader :command_name
+
+    # @return [Integer] The ID of the command.
+    attr_reader :command_id
+
+    # @return [String, nil] The name of the subcommand group relevant to this event.
+    attr_reader :subcommand_group
+
+    # @return [String, nil] The name of the subcommand relevant to this event.
+    attr_reader :subcommand
+
+    # @return [Resolved]
+    attr_reader :resolved
+
+    # @return [Hash<Symbol, Object>] Arguments provided to the command, mapped as `Name => Value`.
+    attr_reader :options
+
+    # @return [Integer, nil] The target of this command when it is a context command.
+    attr_reader :target_id
+
+    def initialize(data, bot)
+      super
+
+      command_data = data["data"]
+
+      @command_id = command_data["id"]
+      @command_name = command_data["name"].to_sym
+
+      @target_id = command_data["target_id"]&.to_i
+      @resolved = Resolved.new({}, {}, {}, {}, {}, {})
+      process_resolved(command_data["resolved"]) if command_data["resolved"]
+
+      options = command_data["options"] || []
+
+      if options.empty?
+        @options = {}
+        return
+      end
+
+      case options[0]["type"]
+      when 2
+        options = options[0]
+        @subcommand_group = options["name"].to_sym
+        @subcommand = options["options"][0]["name"].to_sym
+        options = options["options"][0]["options"]
+      when 1
+        options = options[0]
+        @subcommand = options["name"].to_sym
+        options = options["options"]
+      end
+
+      @options = transform_options_hash(options || {})
+    end
+
+    # @return [Message, User, nil] The target of this command, for context commands.
+    def target
+      return nil unless @target_id
+
+      @resolved.find { |data| data.key?(@target_id) }[@target_id]
+    end
+
+    private
+
+    def process_resolved(resolved_data)
+      resolved_data["users"]&.each do |id, data|
+        @resolved[:users][id.to_i] = @bot.ensure_user(data)
+      end
+
+      resolved_data["roles"]&.each do |id, data|
+        @resolved[:roles][id.to_i] = Rubycord::Role.new(data, @bot)
+      end
+
+      resolved_data["channels"]&.each do |id, data|
+        data["guild_id"] = @interaction.server_id
+        @resolved[:channels][id.to_i] = Rubycord::Channel.new(data, @bot)
+      end
+
+      resolved_data["members"]&.each do |id, data|
+        data["user"] = resolved_data["users"][id]
+        data["guild_id"] = @interaction.server_id
+        @resolved[:members][id.to_i] = Rubycord::Member.new(data, nil, @bot)
+      end
+
+      resolved_data["messages"]&.each do |id, data|
+        @resolved[:messages][id.to_i] = Rubycord::Message.new(data, @bot)
+      end
+
+      resolved_data["attachments"]&.each do |id, data|
+        @resolved[:attachments][id.to_i] = Rubycord::Attachment.new(data, nil, @bot)
+      end
+    end
+
+    def transform_options_hash(hash)
+      hash.to_h { |opt| [opt["name"], opt["options"] || opt["value"]] }
+    end
+  end
+
+  # Event handler for ApplicationCommandEvents.
+  class ApplicationCommandEventHandler < EventHandler
+    # @return [Hash]
+    attr_reader :subcommands
+
+    # @!visibility private
+    def initialize(attributes, block)
+      super
+
+      @subcommands = {}
+    end
+
+    # @param name [Symbol, String]
+    # @yieldparam [SubcommandBuilder]
+    # @return [ApplicationCommandEventHandler]
+    def group(name)
+      raise ArgumentError, "Unable to mix subcommands and groups" if @subcommands.any? { |_, v| v.is_a? Proc }
+
+      builder = SubcommandBuilder.new(name)
+      yield builder
+
+      @subcommands.merge!(builder.to_h)
+      self
+    end
+
+    # @param name [String, Symbol]
+    # @yieldparam [SubcommandBuilder]
+    # @return [ApplicationCommandEventHandler]
+    def subcommand(name, &block)
+      raise ArgumentError, "Unable to mix subcommands and groups" if @subcommands.any? { |_, v| v.is_a? Hash }
+
+      @subcommands[name.to_sym] = block
+
+      self
+    end
+
+    # @!visibility private
+    # @param event [Event]
+    def call(event)
+      return unless matches?(event)
+
+      if event.subcommand_group
+        unless (cmd = @subcommands.dig(event.subcommand_group, event.subcommand))
+          Rubycord::LOGGER.debug("Received an event for an unhandled subcommand `#{event.command_name} #{event.subcommand_group} #{event.subcommand}'")
+          return
+        end
+
+        cmd.call(event)
+      elsif event.subcommand
+        unless (cmd = @subcommands[event.subcommand])
+          Rubycord::LOGGER.debug("Received an event for an unhandled subcommand `#{event.command_name} #{event.subcommand}'")
+          return
+        end
+
+        cmd.call(event)
+      else
+        @block.call(event)
+      end
+    end
+
+    # @!visibility private
+    def matches?(event)
+      return false unless event.is_a? ApplicationCommandEvent
+
+      [
+        matches_all(@attributes[:name], event.command_name) do |a, e|
+          a.to_sym == e.to_sym
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Builder for adding subcommands to an ApplicationCommandHandler
+  class SubcommandBuilder
+    # @!visibility private
+    # @param group [String, Symbol, nil]
+    def initialize(group = nil)
+      @group = group&.to_sym
+      @subcommands = {}
+    end
+
+    # @param name [Symbol, String]
+    # @yieldparam [ApplicationCommandEvent]
+    def subcommand(name, &block)
+      @subcommands[name.to_sym] = block
+    end
+
+    # @!visibility private
+    def to_h
+      @group ? {@group => @subcommands} : @subcommands
+    end
+  end
+
+  # An event for when a user interacts with a component.
+  class ComponentEvent < InteractionCreateEvent
+    # @return [String] User provided data for this button.
+    attr_reader :custom_id
+
+    # @return [Interactions::Message, nil] The message the button originates from.
+    attr_reader :message
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @message = Rubycord::Interactions::Message.new(data["message"], bot, @interaction) if data["message"]
+      @custom_id = data["data"]["custom_id"]
+    end
+  end
+
+  # Generic handler for component events.
+  class ComponentEventHandler < InteractionCreateEventHandler
+    def matches?(event)
+      return false unless super
+      return false unless event.is_a? ComponentEvent
+
+      [
+        matches_all(@attributes[:custom_id], event.custom_id) do |a, e|
+          # Match regexp and strings
+          case a
+          when Regexp
+            a.match?(e)
+          else
+            a == e
+          end
+        end,
+        matches_all(@attributes[:message], event.message) do |a, e|
+          case a
+          when String, Integer
+            a.resolve_id == e.id
+          else
+            a.id == e.id
+          end
+        end
+      ].reduce(&:&)
+    end
+  end
+
+  # An event for when a user interacts with a button component.
+  class ButtonEvent < ComponentEvent
+  end
+
+  # Event handler for a Button interaction event.
+  class ButtonEventHandler < ComponentEventHandler
+  end
+
+  # Event for when a user interacts with a select string component.
+  class StringSelectEvent < ComponentEvent
+    # @return [Array<String>] Selected values.
+    attr_reader :values
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @values = data["data"]["values"]
+    end
+  end
+
+  # Event handler for a select string component.
+  class StringSelectEventHandler < ComponentEventHandler
+  end
+
+  # An event for when a user submits a modal.
+  class ModalSubmitEvent < ComponentEvent
+    # @return [Array<TextInputComponent>]
+    attr_reader :components
+
+    # Get the value of an input passed to the modal.
+    # @param custom_id [String] The custom ID of the component to look for.
+    # @return [String, nil]
+    def value(custom_id)
+      get_component(custom_id)&.value
+    end
+  end
+
+  # Event handler for a modal submission.
+  class ModalSubmitEventHandler < ComponentEventHandler
+  end
+
+  # Event for when a user interacts with a select user component.
+  class UserSelectEvent < ComponentEvent
+    # @return [Array<User>] Selected values.
+    attr_reader :values
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @values = data["data"]["values"].map { |e| bot.user(e) }
+    end
+  end
+
+  # Event handler for a select user component.
+  class UserSelectEventHandler < ComponentEventHandler
+  end
+
+  # Event for when a user interacts with a select role component.
+  class RoleSelectEvent < ComponentEvent
+    # @return [Array<Role>] Selected values.
+    attr_reader :values
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @values = data["data"]["values"].map { |e| bot.server(data["guild_id"]).role(e) }
+    end
+  end
+
+  # Event handler for a select role component.
+  class RoleSelectEventHandler < ComponentEventHandler
+  end
+
+  # Event for when a user interacts with a select mentionable component.
+  class MentionableSelectEvent < ComponentEvent
+    # @return [Hash<Symbol => Array<User>, Symbol => Array<Role>>] Selected values.
+    attr_reader :values
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      users = data["data"]["resolved"]["users"].keys.map { |e| bot.user(e) }
+      roles = data["data"]["resolved"]["roles"] ? data["data"]["resolved"]["roles"].keys.map { |e| bot.server(data["guild_id"]).role(e) } : []
+      @values = {users: users, roles: roles}
+    end
+  end
+
+  # Event handler for a select mentionable component.
+  class MentionableSelectEventHandler < ComponentEventHandler
+  end
+
+  # Event for when a user interacts with a select channel component.
+  class ChannelSelectEvent < ComponentEvent
+    # @return [Array<Channel>] Selected values.
+    attr_reader :values
+
+    # @!visibility private
+    def initialize(data, bot)
+      super
+
+      @values = data["data"]["values"].map { |e| bot.channel(e, bot.server(data["guild_id"])) }
+    end
+  end
+
+  # Event handler for a select channel component.
+  class ChannelSelectEventHandler < ComponentEventHandler
+  end
+end

data/lib/rubycord/events/invites.rb

@@ -0,0 +1,123 @@
+module Rubycord::Events
+  # Raised when an invite is created.
+  class InviteCreateEvent < Event
+    # @return [Invite] The invite that was created.
+    attr_reader :invite
+
+    # @return [Server, nil] The server the invite was created for.
+    attr_reader :server
+
+    # @return [Channel] The channel the invite was created for.
+    attr_reader :channel
+
+    # @!attribute [r] code
+    #   @return [String] The code for the created invite.
+    #   @see Invite#code
+    # @!attribute [r] created_at
+    #   @return [Time] The time the invite was created at.
+    #   @see Invite#created_at
+    # @!attribute [r] max_age
+    #   @return [Integer] The maximum age of the created invite.
+    #   @see Invite#max_age
+    # @!attribute [r] max_uses
+    #   @return [Integer] The maximum number of uses before the invite expires.
+    #   @see Invite#max_uses
+    # @!attribute [r] temporary
+    #   @return [true, false] Whether or not this invite grants temporary membership.
+    #   @see Invite#temporary
+    # @!attribute [r] inviter
+    #   @return [User] The user that created the invite.
+    #   @see Invite#inviter
+    delegate :code, :created_at, :max_age, :max_uses, :temporary, :inviter, to: :invite
+
+    alias_method :temporary?, :temporary
+
+    def initialize(data, invite, bot)
+      @bot = bot
+      @invite = invite
+      @channel = bot.channel(data["channel_id"])
+      @server = bot.server(data["guild_id"]) if data["guild_id"]
+    end
+  end
+
+  # Raised when an invite is deleted.
+  class InviteDeleteEvent < Event
+    # @return [Channel] The channel the deleted invite was for.
+    attr_reader :channel
+
+    # @return [Server, nil] The server the deleted invite was for.
+    attr_reader :server
+
+    # @return [String] The code of the deleted invite.
+    attr_reader :code
+
+    def initialize(data, bot)
+      @bot = bot
+      @channel = bot.channel(data["channel_id"])
+      @server = bot.server(data["guild_id"]) if data["guild_id"]
+      @code = data["code"]
+    end
+  end
+
+  # Event handler for InviteCreateEvent.
+  class InviteCreateEventHandler < EventHandler
+    def matches?(event)
+      return false unless event.is_a? InviteCreateEvent
+
+      [
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:channel], event.channel) do |a, e|
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:temporary], event.temporary?, &:==),
+        matches_all(@attributes[:inviter], event.inviter, &:==)
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Event handler for InviteDeleteEvent
+  class InviteDeleteEventHandler < EventHandler
+    def matches?(event)
+      return false unless event.is_a? InviteDeleteEvent
+
+      [
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end,
+        matches_all(@attributes[:channel], event.channel) do |a, e|
+          a == case a
+          when String
+            e.name
+          when Integer
+            e.id
+          else
+            e
+          end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+end

data/lib/rubycord/events/lifetime.rb

@@ -0,0 +1,29 @@
+require "rubycord/events/generic"
+
+module Rubycord::Events
+  # Common superclass for all lifetime events
+  class LifetimeEvent < Event
+    # @!visibility private
+    def initialize(bot)
+      @bot = bot
+    end
+  end
+
+  # @see Rubycord::EventContainer#ready
+  class ReadyEvent < LifetimeEvent; end
+
+  # Event handler for {ReadyEvent}
+  class ReadyEventHandler < TrueEventHandler; end
+
+  # @see Rubycord::EventContainer#disconnected
+  class DisconnectEvent < LifetimeEvent; end
+
+  # Event handler for {DisconnectEvent}
+  class DisconnectEventHandler < TrueEventHandler; end
+
+  # @see Rubycord::EventContainer#heartbeat
+  class HeartbeatEvent < LifetimeEvent; end
+
+  # Event handler for {HeartbeatEvent}
+  class HeartbeatEventHandler < TrueEventHandler; end
+end