zhdev/oblak
1
0
Fork 0
Code Issues Pull requests Activity

✨ Add a PircBotX implementation of cloud

Browse source
This commit is contained in:
Alexander Söderberg 2020-10-22 10:51:33 +02:00 • committed by Alexander Söderberg
parent c74ac64e5f
commit 979d1079c6
9 changed files with 484 additions and 3 deletions
Download patch file Download diff file Expand all files Collapse all files

1
CHANGELOG.md
View file

@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
- Added CaptionKeys to cloud-bungee
- Added BungeeCommandPreprocessor to cloud-bungee
- Added named suggestion providers
- Added a PircBotX implementation
### Changed
- Allow for combined presence flags, such that `-a -b -c` is equivalent to `-abc`

7
README.md
View file

@ -61,9 +61,9 @@ command completion and suggestions.
If using the annotation parsing system, you can create custom annotation mappers to use your own annotation bindings for
command parsing, preprocessing, etc.
Cloud by default ships with implementations and mappings for the most common Minecraft server platforms and JDA and javacord for
Discord bots. The core
module allows you to use Cloud anywhere, simply by implementing the CommandManager for the platform of your choice.
Cloud by default ships with implementations and mappings for the most common Minecraft server platforms, JDA and javacord for
Discord bots and PircBotX for IRC.
The core module allows you to use Cloud anywhere, simply by implementing the CommandManager for the platform of your choice.
The code is based on a (W.I.P) paper that can be found [here](https://github.com/Sauilitired/Sauilitired/blob/master/AS_2020_09_Commands.pdf).
@ -89,6 +89,7 @@ The code is based on a (W.I.P) paper that can be found [here](https://github.com
- **cloud-minecraft/cloud-minecraft-extras**: Opinionated Extra Features for cloud-minecraft
- **cloud-discord/cloud-jda**: JDA v4.2.0_209+ implementation of cloud
- **cloud-discord/cloud-javacord**: Javacord v3.1.1+ implementation of cloud
- **cloud-irc/cloud-pircbotx**: PircBotX 2.0+ implementation of cloud
## links

99
cloud-irc/cloud-pircbotx/src/main/java/cloud/commandframework/pircbotx/CloudListenerAdapter.java Normal file
View file

@ -0,0 +1,99 @@
//
// MIT License
//
// Copyright (c) 2020 Alexander Söderberg & Contributors
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
package cloud.commandframework.pircbotx;
import cloud.commandframework.exceptions.ArgumentParseException;
import cloud.commandframework.exceptions.InvalidCommandSenderException;
import cloud.commandframework.exceptions.InvalidSyntaxException;
import cloud.commandframework.exceptions.NoPermissionException;
import cloud.commandframework.exceptions.NoSuchCommandException;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.pircbotx.hooks.ListenerAdapter;
import org.pircbotx.hooks.types.GenericMessageEvent;
final class CloudListenerAdapter<C> extends ListenerAdapter {
private static final String MESSAGE_INVALID_SYNTAX = "Invalid Command Syntax. Correct command syntax is: ";
private static final String MESSAGE_NO_PERMS = "I'm sorry, but you do not have permission to perform this command. "
+ "Please contact the server administrators if you believe that this is in error.";
private static final String MESSAGE_UNKNOWN_COMMAND = "Unknown command";
private final PircBotXCommandManager<C> manager;
CloudListenerAdapter(final @NonNull PircBotXCommandManager<C> manager) {
this.manager = manager;
}
@Override
public void onGenericMessage(final @NonNull GenericMessageEvent event) {
final String message = event.getMessage();
if (!message.startsWith(this.manager.getCommandPrefix())) {
return;
}
final C sender = this.manager.getUserMapper().apply(event.getUser());
manager.executeCommand(sender, message.substring(this.manager.getCommandPrefix().length()))
.whenComplete((commandResult, throwable) -> {
if (throwable == null) {
return;
}
if (throwable instanceof InvalidSyntaxException) {
this.manager.handleException(sender,
InvalidSyntaxException.class,
(InvalidSyntaxException) throwable, (c, e) -> event.respondWith(
MESSAGE_INVALID_SYNTAX + this.manager.getCommandPrefix()
+ ((InvalidSyntaxException) throwable).getCorrectSyntax()
)
);
} else if (throwable instanceof InvalidCommandSenderException) {
this.manager.handleException(sender,
InvalidCommandSenderException.class,
(InvalidCommandSenderException) throwable, (c, e) ->
event.respondWith(throwable.getMessage())
);
} else if (throwable instanceof NoPermissionException) {
this.manager.handleException(sender,
NoPermissionException.class,
(NoPermissionException) throwable, (c, e) ->
event.respondWith(MESSAGE_NO_PERMS)
);
} else if (throwable instanceof NoSuchCommandException) {
this.manager.handleException(sender,
NoSuchCommandException.class,
(NoSuchCommandException) throwable, (c, e) ->
event.respondWith(MESSAGE_UNKNOWN_COMMAND)
);
} else if (throwable instanceof ArgumentParseException) {
this.manager.handleException(sender, ArgumentParseException.class,
(ArgumentParseException) throwable, (c, e) -> event.respondWith(
"Invalid Command Argument: " + throwable.getCause().getMessage()
)
);
} else {
event.respondWith(throwable.getMessage());
}
});
}
}

141
cloud-irc/cloud-pircbotx/src/main/java/cloud/commandframework/pircbotx/PircBotXCommandManager.java Normal file
View file

@ -0,0 +1,141 @@
//
// MIT License
//
// Copyright (c) 2020 Alexander Söderberg & Contributors
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
package cloud.commandframework.pircbotx;
import cloud.commandframework.CommandManager;
import cloud.commandframework.CommandTree;
import cloud.commandframework.captions.Caption;
import cloud.commandframework.captions.FactoryDelegatingCaptionRegistry;
import cloud.commandframework.execution.AsynchronousCommandExecutionCoordinator;
import cloud.commandframework.execution.CommandExecutionCoordinator;
import cloud.commandframework.internal.CommandRegistrationHandler;
import cloud.commandframework.meta.CommandMeta;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.pircbotx.PircBotX;
import org.pircbotx.User;
import java.util.function.BiFunction;
import java.util.function.Function;
/**
* Command manager implementation for PircBotX 2.0
*
* @param <C> Command sender type
* @since 1.1.0
*/
public class PircBotXCommandManager<C> extends CommandManager<C> {
/**
* Meta key for accessing the {@link org.pircbotx.PircBotX} instance from a
* {@link cloud.commandframework.context.CommandContext} instance
*/
public static final String PIRCBOTX_META_KEY = "__internal_pircbotx__";
/**
* Variables: {input}
*/
public static final Caption ARGUMENT_PARSE_FAILURE_USER_KEY = Caption.of("argument.parse.failure.use");
/**
* Default caption for {@link #ARGUMENT_PARSE_FAILURE_USER_KEY}
*/
public static final String ARGUMENT_PARSE_FAILURE_USER = "'{input}' is not a valid user";
private final String commandPrefix;
private final BiFunction<C, String, Boolean> permissionFunction;
private final Function<User, C> userMapper;
private final PircBotX pircBotX;
/**
* Create a new command manager instance
*
* @param pircBotX PircBotX instance. This is used to register the
* {@link org.pircbotx.hooks.ListenerAdapter} that will forward commands to the
* command dispatcher
* @param commandExecutionCoordinator Execution coordinator instance. The coordinator is in charge of executing incoming
* commands. Some considerations must be made when picking a suitable execution coordinator
* for your platform. For example, an entirely asynchronous coordinator is not suitable
* when the parsers used in that particular platform are not thread safe. If you have
* commands that perform blocking operations, however, it might not be a good idea to
* use a synchronous execution coordinator. In most cases you will want to pick between
* {@link CommandExecutionCoordinator#simpleCoordinator()} and
* {@link AsynchronousCommandExecutionCoordinator}
* @param commandRegistrationHandler Command registration handler. This will get called every time a new command is
* registered to the command manager. This may be used to forward command registration
* @param permissionFunction Function used to determine whether or not a sender is permitted to use a certain
* command. The first input is the sender of the command, and the second parameter is
* the the command permission string. The return value should be {@code true} if the
* sender is permitted to use the command, else {@code false}
* @param userMapper Function that maps {@link User users} to the custom command sender type
* @param commandPrefix The prefix that must be applied to all commands for the command to be valid
*/
public PircBotXCommandManager(
final @NonNull PircBotX pircBotX,
final @NonNull Function<@NonNull CommandTree<C>, @NonNull CommandExecutionCoordinator<C>> commandExecutionCoordinator,
final @NonNull CommandRegistrationHandler commandRegistrationHandler,
final @NonNull BiFunction<C, String, Boolean> permissionFunction,
final @NonNull Function<User, C> userMapper,
final @NonNull String commandPrefix
) {
super(commandExecutionCoordinator, commandRegistrationHandler);
this.pircBotX = pircBotX;
this.permissionFunction = permissionFunction;
this.commandPrefix = commandPrefix;
this.userMapper = userMapper;
this.pircBotX.getConfiguration().getListenerManager().addListener(new CloudListenerAdapter<>(this));
if (this.getCaptionRegistry() instanceof FactoryDelegatingCaptionRegistry) {
((FactoryDelegatingCaptionRegistry<C>) this.getCaptionRegistry()).registerMessageFactory(
ARGUMENT_PARSE_FAILURE_USER_KEY,
(caption, user) -> ARGUMENT_PARSE_FAILURE_USER
);
}
this.registerCommandPreProcessor(context -> context.getCommandContext().store(PIRCBOTX_META_KEY, pircBotX));
}
@Override
public final boolean hasPermission(
@NonNull final C sender,
@NonNull final String permission
) {
return this.permissionFunction.apply(sender, permission);
}
@Override
public final @NonNull CommandMeta createDefaultCommandMeta() {
return CommandMeta.simple().build();
}
/**
* Get the command prefix. A message should be classed as a command if, and only if, it is prefixed
* with this prefix
*
* @return Command prefix
*/
public final @NonNull String getCommandPrefix() {
return this.commandPrefix;
}
@NonNull final Function<User, C> getUserMapper() {
return this.userMapper;
}
}

178
cloud-irc/cloud-pircbotx/src/main/java/cloud/commandframework/pircbotx/arguments/UserArgument.java Normal file
View file

@ -0,0 +1,178 @@
//
// MIT License
//
// Copyright (c) 2020 Alexander Söderberg & Contributors
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
package cloud.commandframework.pircbotx.arguments;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.captions.CaptionVariable;
import cloud.commandframework.context.CommandContext;
import cloud.commandframework.exceptions.parsing.NoInputProvidedException;
import cloud.commandframework.exceptions.parsing.ParserException;
import cloud.commandframework.pircbotx.PircBotXCommandManager;
import io.leangen.geantyref.TypeToken;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.pircbotx.PircBotX;
import org.pircbotx.User;
import org.pircbotx.exception.DaoException;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.function.BiFunction;
/**
* {@link CommandArgument Command argument} that parses PircBotX {@link User users}
*
* @param <C> Command sender type
* @since 1.1.0
*/
public final class UserArgument<C> extends CommandArgument<C, User> {
private UserArgument(
final boolean required,
final @NonNull String name,
final @Nullable BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider
) {
super(
required,
name,
new UserArgumentParser<>(),
"",
TypeToken.get(User.class),
suggestionsProvider,
new LinkedList<>()
);
}
/**
* Create a new user argument builder
*
* @param name Argument name
* @param <C> Command sender type
* @return Builder instance
*/
public static <C> @NonNull Builder<C> newBuilder(final @NonNull String name) {
return new Builder<>(name);
}
/**
* Create a new required user argument
*
* @param name Argument name
* @param <C> Command sender type
* @return Argument instance
*/
public static <C> @NonNull CommandArgument<C, User> of(final @NonNull String name) {
return UserArgument.<C>newBuilder(name).asRequired().build();
}
/**
* Create a optional user argument
*
* @param name Argument name
* @param <C> Command sender type
* @return Argument instance
*/
public static <C> @NonNull CommandArgument<C, User> optional(final @NonNull String name) {
return UserArgument.<C>newBuilder(name).asOptional().build();
}
public static final class Builder<C> extends CommandArgument.Builder<C, User> {
private Builder(
final @NonNull String name
) {
super(
TypeToken.get(User.class),
name
);
}
@Override
public @NonNull CommandArgument<@NonNull C, @NonNull User> build() {
return new UserArgument<>(
this.isRequired(),
this.getName(),
this.getSuggestionsProvider()
);
}
}
public static final class UserArgumentParser<C> implements ArgumentParser<C, User> {
@Override
public @NonNull ArgumentParseResult<@NonNull User> parse(
@NonNull final CommandContext<@NonNull C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue
) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NoInputProvidedException(
UserArgumentParser.class,
commandContext
));
}
final PircBotX pircBotX = commandContext.get(PircBotXCommandManager.PIRCBOTX_META_KEY);
final User user;
try {
user = pircBotX.getUserChannelDao().getUser(input);
} catch (final DaoException exception) {
return ArgumentParseResult.failure(
new UserParseException(
commandContext,
input
)
);
}
return ArgumentParseResult.success(user);
}
}
public static final class UserParseException extends ParserException {
private UserParseException(
final @NonNull CommandContext<?> context,
final @NonNull String input
) {
super(
UserArgumentParser.class,
context,
PircBotXCommandManager.ARGUMENT_PARSE_FAILURE_USER_KEY,
CaptionVariable.of(
"input",
input
)
);
}
}
}

28
cloud-irc/cloud-pircbotx/src/main/java/cloud/commandframework/pircbotx/arguments/package-info.java Normal file
View file

@ -0,0 +1,28 @@
//
// MIT License
//
// Copyright (c) 2020 Alexander Söderberg & Contributors
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
/**
* PircBotX specific arguments
*/
package cloud.commandframework.pircbotx.arguments;

28
cloud-irc/cloud-pircbotx/src/main/java/cloud/commandframework/pircbotx/package-info.java Normal file
View file

@ -0,0 +1,28 @@
//
// MIT License
//
// Copyright (c) 2020 Alexander Söderberg & Contributors
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
/**
* PircBotX 2.0 implementation of Cloud
*/
package cloud.commandframework.pircbotx;

2
scripts/dependencies.gradle
View file

@ -14,6 +14,8 @@ ext {
'adventure-api' : '4.1.1',
'paper-api' : '1.15.2-R0.1-SNAPSHOT',
'velocity-api' : '1.1.0-SNAPSHOT',
// IRC DEPENDENCIES
'pircbotx' : '2.1',
// TEST DEPENDENCIES
'jupiter-engine': '5.7.0',
'jhm' : '1.25.2'

3
settings.gradle
View file

@ -32,6 +32,9 @@ include(':cloud-sponge')
project(':cloud-sponge').projectDir = file('cloud-minecraft/cloud-sponge')
include(':cloud-velocity')
project(':cloud-velocity').projectDir = file('cloud-minecraft/cloud-velocity')
// IRC Modules
include(':cloud-pircbotx')
project(':cloud-pircbotx').projectDir = file('cloud-irc/cloud-pircbotx')
//
// Example Modules
//