onyxcord 2.1.0 → 3.2.0

data/lib/onyxcord/interactions/internal/permission_builder.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module Interactions
+    # Builder for creating server application command permissions.
+    # @deprecated This system is being replaced in the near future.
+    class PermissionBuilder
+      # Role permission type
+      ROLE = 1
+      # User permission type
+      USER = 2
+
+      # @!visibility hidden
+      def initialize
+        @permissions = []
+      end
+
+      # Allow a role to use this command.
+      # @param role_id [Integer]
+      # @return [PermissionBuilder]
+      def allow_role(role_id)
+        create_entry(role_id, ROLE, true)
+      end
+
+      # Deny a role usage of this command.
+      # @param role_id [Integer]
+      # @return [PermissionBuilder]
+      def deny_role(role_id)
+        create_entry(role_id, ROLE, false)
+      end
+
+      # Allow a user to use this command.
+      # @param user_id [Integer]
+      # @return [PermissionBuilder]
+      def allow_user(user_id)
+        create_entry(user_id, USER, true)
+      end
+
+      # Deny a user usage of this command.
+      # @param user_id [Integer]
+      # @return [PermissionBuilder]
+      def deny_user(user_id)
+        create_entry(user_id, USER, false)
+      end
+
+      # Allow an entity to use this command.
+      # @param object [Role, User, Member]
+      # @return [PermissionBuilder]
+      # @raise [ArgumentError]
+      def allow(object)
+        case object
+        when OnyxCord::User, OnyxCord::Member
+          create_entry(object.id, USER, true)
+        when OnyxCord::Role
+          create_entry(object.id, ROLE, true)
+        else
+          raise ArgumentError, "Unable to create permission for unknown type: #{object.class}"
+        end
+      end
+
+      # Deny an entity usage of this command.
+      # @param object [Role, User, Member]
+      # @return [PermissionBuilder]
+      # @raise [ArgumentError]
+      def deny(object)
+        case object
+        when OnyxCord::User, OnyxCord::Member
+          create_entry(object.id, USER, false)
+        when OnyxCord::Role
+          create_entry(object.id, ROLE, false)
+        else
+          raise ArgumentError, "Unable to create permission for unknown type: #{object.class}"
+        end
+      end
+
+      # @!visibility private
+      # @return [Array<Hash>]
+      def to_a
+        @permissions
+      end
+
+      private
+
+      def create_entry(id, type, permission)
+        @permissions << { id: id, type: type, permission: permission }
+        self
+      end
+    end
+  end
+end

data/lib/onyxcord/interactions/option.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module Interactions
+    class Option
+      attr_reader :name, :description, :type, :attributes, :options
+
+      OPTION_TYPES = {
+        subcommand: 1,
+        subcommand_group: 2,
+        string: 3,
+        integer: 4,
+        boolean: 5,
+        user: 6,
+        channel: 7,
+        role: 8,
+        mentionable: 9,
+        number: 10,
+        attachment: 11
+      }.freeze
+
+      SKIP_OPTION_TYPES = %i[subcommand subcommand_group].freeze
+
+      OPTION_METHODS = OPTION_TYPES.each_with_object({}) do |(name, value), hash|
+        next if SKIP_OPTION_TYPES.include?(name)
+
+        hash[name] = value
+      end.freeze
+
+      def initialize(name, description, type, **attributes, &block)
+        @name = name.to_s
+        @description = description
+        @type = type
+        @attributes = attributes
+        @options = []
+        @block = block
+
+        instance_eval(&@block) if @block && type == :subcommand
+      end
+
+      def to_h
+        data = {
+          name: @name,
+          description: @description,
+          type: OPTION_TYPES[@type] || @type
+        }
+
+        data[:name_localizations] = @attributes[:name_localizations] if @attributes[:name_localizations]
+        data[:description_localizations] = @attributes[:description_localizations] if @attributes[:description_localizations]
+        data[:required] = @attributes[:required] unless @attributes[:required].nil?
+        data[:min_length] = @attributes[:min_length] if @attributes[:min_length]
+        data[:max_length] = @attributes[:max_length] if @attributes[:max_length]
+        data[:min_value] = @attributes[:min_value] if @attributes[:min_value]
+        data[:max_value] = @attributes[:max_value] if @attributes[:max_value]
+        data[:autocomplete] = @attributes[:autocomplete] unless @attributes[:autocomplete].nil?
+        data[:channel_types] = @attributes[:channel_types] if @attributes[:channel_types]
+
+        if @attributes[:choices]
+          choice_localizations = @attributes[:choice_localizations] || {}
+          data[:choices] = @attributes[:choices].map do |choice_name, value|
+            choice = { name: choice_name.to_s, value: value }
+            locs = choice_localizations[choice_name] || choice_localizations[choice_name.to_s]
+            choice[:name_localizations] = locs if locs
+            choice
+          end
+        end
+
+        data[:options] = @options.map(&:to_h) unless @options.empty?
+
+        data
+      end
+
+      def subcommand(name, description, **attrs, &block)
+        sub = Option.new(name, description, :subcommand, **attrs, &block)
+        @options << sub
+        sub
+      end
+
+      OPTION_METHODS.each do |method_name, option_type|
+        define_method(method_name) do |name, description = '', **attrs, &blk|
+          opt = Option.new(name, description, option_type, **attrs, &blk)
+          @options << opt
+          opt
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/interactions/registry.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module Interactions
+    class Registry
+      attr_reader :bot, :commands
+
+      def initialize(bot)
+        @bot = bot
+        @commands = {}
+      end
+
+      def slash(name, description:, **attributes, &block)
+        register(Command.chat_input(name, description: description, **attributes, &block))
+      end
+
+      def user(name, **attributes, &block)
+        register(Command.user(name, **attributes, &block))
+      end
+
+      def message(name, **attributes, &block)
+        register(Command.message(name, **attributes, &block))
+      end
+
+      def register(command)
+        @commands[command.name] = command
+        wire_handler(command)
+        command
+      end
+
+      def sync!(server_id: nil, delete_unknown: false) # rubocop:disable Lint/UnusedMethodArgument
+        payload = @commands.values.map(&:to_h)
+
+        if server_id
+          @bot.bulk_overwrite_guild_application_commands(server_id, payload)
+        else
+          @bot.bulk_overwrite_global_application_commands(payload)
+        end
+      end
+
+      private
+
+      def wire_handler(command)
+        @bot.application_command(command.name) do |event|
+          command.call(Context.new(event, command))
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/interactions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'onyxcord/interactions/option'
+require 'onyxcord/interactions/command'
+require 'onyxcord/interactions/context'
+require 'onyxcord/interactions/registry'
+require 'onyxcord/interactions/internal/application_command'
+require 'onyxcord/interactions/internal/option_builder'
+require 'onyxcord/interactions/internal/permission_builder'
+require 'onyxcord/interactions/internal/message'
+require 'onyxcord/interactions/internal/metadata'
+
+module OnyxCord
+  module Interactions
+  end
+end

data/lib/onyxcord/internal/async_runtime.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'async'
+
+module OnyxCord
+  module Internal
+    module AsyncRuntime
+      module_function
+
+      def run(&block)
+        current = Async::Task.current?
+        return yield current if current
+
+        Sync(&block)
+      end
+
+      def async(&block)
+        current = Async::Task.current?
+        return current.async(&block) if current
+
+        Async(&block)
+      end
+
+      def sleep(duration)
+        task = Async::Task.current?
+        return task.sleep(duration) if task.respond_to?(:sleep)
+
+        Kernel.sleep(duration)
+      end
+    end
+  end
+end