-
-
Notifications
You must be signed in to change notification settings - Fork 75
Make NativeProxyCommandSender extend CraftBukkit class ProxiedNativeCommandSender #478
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Make NativeProxyCommandSender extend CraftBukkit class ProxiedNativeCommandSender #478
Conversation
JorelAli
left a comment
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Looks good to me. Seems like something we're more than happy to add to a 10.0.0 release due to backwards-incompatible changes.
I think I should probably start making a separate branch for 10.0.0 stuff because we've got a lot of backwards-incompatible PRs that we can't/shouldn't merge to dev/dev in the event we want to release 9.10.0 (e.g. for the Folia fix and/or upcoming Minecraft versions)
|
Created branch |
There should be a new way for developers to create their own TODO:
|
9d90668 to
423df48
Compare
2b438f3 to
eb4b6e8
Compare
eb4b6e8 to
3327ff6
Compare
3327ff6 to
b3d6965
Compare
b3d6965 to
f18c081
Compare
84b81e7 to
a75e4e4
Compare
a75e4e4 to
7b09a17
Compare
20095f3 to
bebca9c
Compare
bebca9c to
53ae7f1
Compare
53ae7f1 to
9836d19
Compare
9836d19 to
17d208c
Compare
17d208c to
32bbe6d
Compare
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
32bbe6d to
f5dcf04
Compare
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
f5dcf04 to
eb03bb5
Compare
eb03bb5 to
27993ba
Compare
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Logic from #580 removed, since wrapping the NullCommandSender no longer needs to be handled as a special case
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Logic from #580 removed, since wrapping the NullCommandSender no longer needs to be handled as a special case
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Logic from #580 removed, since wrapping the NullCommandSender no longer needs to be handled as a special case
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
27993ba to
17c66fe
Compare
17c66fe to
275479b
Compare
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Logic from #580 removed, since wrapping the NullCommandSender no longer needs to be handled as a special case
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Logic from #580 removed, since wrapping the NullCommandSender no longer needs to be handled as a special case
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Logic from #580 removed, since wrapping the NullCommandSender no longer needs to be handled as a special case
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
Note: This commit makes this branch backwards incompatible, especially for non-DSL Kotlin code (see `commandapi-documentation-code/.../Examples.kt`). "Standard" Java and DSL API code usage looks the same, but I'm pretty sure plugins will need to recompile due to changes to the `FunctionalInterface`s. There are also some smaller public API changes, mentioned below.
Notable changes:
- Removed `AbstractCommandSender` and all its implemenations (i.e. the `dev.jorel.commandapi.commandsenders` package is completely gone)
- Logic in `CommandAPIHandler#generateBrigadierRequirements` for checking if a sender satisfies a `CommandPermission` was moved to `CommandAPIPlatform#getPermissionCheck`
- Previously, methods in `AbstractCommandSender` provided access to `hasPermission` and `isOp`. `CommandAPIBukkit` and `CommandAPIVelocity` now handle these definitions.
- `CommandPermission.TRUE()` and `CommandPermission.FALSE()` added for computing short circuits when combining permissions and requirements
- `PreviewInfo` now has the generic parameter `Player` rather than an `AbstractPlayer`
- Backwards-incompatible (`(Player) player.getSource()` becomes `player`)
- Generic parameter propogates to `PreviewableFunction` and `Previewable`
- `CommandAPIPlatform` methods for convert Brigadier Source to CommandSender simplified
- `getSenderForCommand` removed
- just pass `CommandContext#getSource` into `getCommandSenderFromCommandSource`
- `forceNative` parameter was only used on Bukkit, which is now handled by `NMS#getNativeProxyCommandSender` (more on that below)
- `wrapCommandSender` removed
- Logic from #580 removed, since wrapping the NullCommandSender no longer needs to be handled as a special case
- Wrapping the sender no longer necessary for `getBrigadierSourceFromCommandSender`
- `CommandAPIVelocity` now does nothing in these methods :P
- `CommandAPIExecutor` reworked
- `ExecutorType` moved to platform modules (so Velocity can no longer try to define sender types that don't exist)
- Detecting whether a certain executor can be run by the given class delegated to `BukkitTypedExecutor` and `VelocityTypedExecutor`
- Priority of executors now depends on order of calling the `executes` methods (i.e the priority listed here https://commandapi.jorel.dev/9.4.1/normalexecutors.html#multiple-command-executor-implementations no longer applies)
- Normal executors are no longer ignored if resulting executors exist (not sure if this was a bug or intended)
- Tweaked `ExecutionInfo`
- Added `CommandContext<Source> cmdCtx` to `ExecutionInfo`
- This allows passing the information needed for a `NATIVE` executor on Bukkit to create a `NativeProxyCommandSender`
- Uses `NMS#getNativeProxyCommandSender`, which was adapted from the removed `getSenderForCommand` method
- Note: conflicts with #478, though should be easily resolved
- Note: Velocity can define the `CommandSource` object, though Bukkit has it as `?`. This makes it hard for non DSL Kotlin to infer the type parameters for some reason, which is annoying because you now need to specify the type parameter. I don't know if there's a better way to handle that.
- TODO: Make sure depdendents can still use `ExecutionInfo` without including Brigadier as a dependency
- `ExecutionInfo` is now a record (`BukkitExecutionInfo` and `VelocityExecutionInfo` removed)
- Simplified `dev.jorel.commandapi.executors` package
- Platform and sender specific executor classes (e.g. `PlayerCommandExecutor` and `EntityResultingExecutionInfo`) removed
- Just the functional interfaces `NormalExecutorInfo`, `NormalExecutor`, `ResultingExecutorInfo`, and `ResultingExecutor` now
- `BukkitExecutable` and `VelocityExecutable` link different command sender classes as type parameters to the `ExecutorType` enum values
TODO:
- Add executor tests to `dev/dev` to ensure same behavior
- Especially for `PROXY` and `NATIVE` senders
- Especially for non-DSL Kotlin to see how its lamdba type inference works
- Update documentation
7ab03ee to
bc2396c
Compare
…ommandSender so VanillaCommandWrapper can handle it Fixes CommandAPI#477
Since this doesn't have to worry about NMS compatibility, MockNativeProxyCommandSender is basically the same as the old implementation of NativeProxyCommandSender :P
1fc98a2 to
950f969
Compare
This fixes #477. See that issue for context and a deeper analysis of the problem.
When
VanillaCommandWrapperruns a command, it uses itsgetListenermethod to convert a BukkitCommandSenderinto a VanillaCommandListenerWrapper. When the sender implementsorg.bukkit.command.ProxiedCommandSender, it runs this code:Previously,
dev.jorel.commandapi.wrappers.NativeProxyCommandSenderimplementedProxiedCommandSender, but notProxiedNativeCommandSender, so aClassCastExceptionwas thrown if aNativeProxyCommandSenderever tried to execute a Vanilla command.To fix this issue, instances of
NativeProxyCommandSenderneed to beProxiedNativeCommandSenderobjects. This isn't trivial to do, sinceProxiedNativeCommandSenderis a version-specific CraftBukkit class (org.bukkit.craftbukkit.v1_20_R1.command.ProxiedNativeCommandSenderfor example). It is still possible, you just need to create an implementation ofNativeProxyCommandSenderfor each NMS version, and that is what this PR does.NativeProxyCommandSenderis now an interface, like this:It still inherits all the methods from
ProxiedCommandSenderand adds thegetLocationandgetWorldmethods, as described in the docs.In each of the
commandapi-bukkit-nmsmodules, there is now aNativeProxyCommandSender_(VERSION)class. For example, there is this class incommandapi-bukkit-nms-1.20:The logic for creating a
LocationandWorldfrom theCommandSourceStackwas moved from the implementation ofCommandAPIBukkit#getSenderForCommand. ExtendingProxiedNativeCommandSendertakes care of the implementation for all theProxiedCommandSendermethods (I checked and they look equivalent to the implementations that used to be inNativeProxyCommandSender), so these classes only have to implementgetLocationandgetWorld.Luckily,
NativeProxyCommandSenderwas being constructed in the NMS implementations anyway, so it was easy to change those:Instead of constructing a
NativeProxyCommandSenderdirectly, each NMS uses its version-specific implementation. The logic for extracting theLocationandWorldhas also been moved into the constructor forNativeProxyCommandSender_(VERSION), so it isn't in here anymore.IMPORTANT: This is a breaking API change
Unfortunately,
NativeProxyCommandSendercannot be a class anymore, becauseProxiedNativeCommandSenderis a class, and Java doesn't have multi-class inheritance. This is problematic in two ways.First, developers could have created their own instances of
NativeProxyCommandSenderwith something likenew NativeProxyCommandSender(caller, callee, location, world). SinceNativeProxyCommandSenderis now an interface, it can't be instantiated like that anymore. I wouldn't expect anyone to do that, since usually you are just given aNativeProxyCommandSenderwhen usingexecutesNative, but it might be a problem.Second, a
java.lang.IncompatibleClassChangeErroroccurs when using the plugin version of the CommandAPI. For example, say I compile this command against version9.0.3:Notably, this code uses the method
ProxiedCommandSender#getCalleeon aNativeProxyCommandSenderobject. If I try to run this command using the CommandAPI plugin jar for this PR, I get this exception:As the exception explains, the bytecode for my command expected
NativeProxyCommandSenderto be a class, but it found an interface instead. To fix this, I just need to recompile my plugin since the available methods don't change. Still, code compiled against older versions may not work with this PR if they use methods inNativeProxyCommandSender.There might be some way to avoid these issues, but for now, this PR is incompatible with certain interactions with
NativeProxyCommandSender.TODO:
Apply the changes to the test framework (whoops, forgot that)
Make sure tests run as before
Test NMS code on real servers
getSenderForCommandcreateNativeProxyCommandSenderversions