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

♻️ Reformat + Update .editorconfig

Browse source
This commit is contained in:
Alexander Söderberg 2020-10-06 22:48:30 +02:00 • committed by Alexander Söderberg
parent 8bdec87a74
commit 2aac3980d5
169 changed files with 4261 additions and 2448 deletions
Download patch file Download diff file Expand all files Collapse all files

97
cloud-annotations/src/main/java/cloud/commandframework/annotations/AnnotationParser.java
View file

@ -30,13 +30,13 @@ import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.flags.CommandFlag;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.arguments.parser.ParserParameter;
import cloud.commandframework.arguments.parser.ParserParameters;
import cloud.commandframework.arguments.parser.StandardParameters;
import cloud.commandframework.execution.CommandExecutionHandler;
import cloud.commandframework.extra.confirmation.CommandConfirmationManager;
import cloud.commandframework.meta.CommandMeta;
import cloud.commandframework.meta.SimpleCommandMeta;
import io.leangen.geantyref.TypeToken;
import cloud.commandframework.arguments.parser.ParserParameters;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
@ -77,9 +77,11 @@ public final class AnnotationParser<C> {
* {@link ParserParameter}. Mappers for the
* parser parameters can be registered using {@link #registerAnnotationMapper(Class, Function)}
*/
public AnnotationParser(final @NonNull CommandManager<C> manager,
final @NonNull Class<C> commandSenderClass,
final @NonNull Function<@NonNull ParserParameters, @NonNull CommandMeta> metaMapper) {
public AnnotationParser(
final @NonNull CommandManager<C> manager,
final @NonNull Class<C> commandSenderClass,
final @NonNull Function<@NonNull ParserParameters, @NonNull CommandMeta> metaMapper
) {
this.commandSenderClass = commandSenderClass;
this.manager = manager;
this.metaFactory = new MetaFactory(this, metaMapper);
@ -96,9 +98,11 @@ public final class AnnotationParser<C> {
* @param mapper Mapping function
* @param <A> Annotation type
*/
public <A extends Annotation> void registerAnnotationMapper(final @NonNull Class<A> annotation,
final @NonNull Function<@NonNull A,
@NonNull ParserParameters> mapper) {
public <A extends Annotation> void registerAnnotationMapper(
final @NonNull Class<A> annotation,
final @NonNull Function<@NonNull A,
@NonNull ParserParameters> mapper
) {
this.annotationMappers.put(annotation, mapper);
}
@ -122,8 +126,10 @@ public final class AnnotationParser<C> {
method.setAccessible(true);
}
if (method.getReturnType() != Void.TYPE) {
throw new IllegalArgumentException(String.format("@CommandMethod annotated method '%s' has non-void return type",
method.getName()));
throw new IllegalArgumentException(String.format(
"@CommandMethod annotated method '%s' has non-void return type",
method.getName()
));
}
commandMethodPairs.add(new CommandMethodPair(method, commandMethod));
}
@ -139,7 +145,8 @@ public final class AnnotationParser<C> {
@SuppressWarnings("unchecked")
private @NonNull Collection<@NonNull Command<C>> construct(
final @NonNull Object instance,
final @NonNull Collection<@NonNull CommandMethodPair> methodPairs) {
final @NonNull Collection<@NonNull CommandMethodPair> methodPairs
) {
final Collection<Command<C>> commands = new ArrayList<>();
for (final CommandMethodPair commandMethodPair : methodPairs) {
final CommandMethod commandMethod = commandMethodPair.getCommandMethod();
@ -149,24 +156,28 @@ public final class AnnotationParser<C> {
final String commandToken = commandMethod.value().split(" ")[0].split("\\|")[0];
@SuppressWarnings("ALL") final CommandManager manager = this.manager;
final SimpleCommandMeta.Builder metaBuilder = SimpleCommandMeta.builder()
.with(this.metaFactory.apply(method.getAnnotations()));
.with(this.metaFactory.apply(method.getAnnotations()));
if (method.isAnnotationPresent(Confirmation.class)) {
metaBuilder.with(CommandConfirmationManager.CONFIRMATION_REQUIRED_META, "true");
}
@SuppressWarnings("ALL")
Command.Builder builder = manager.commandBuilder(commandToken,
tokens.get(commandToken).getMinor(),
metaBuilder.build());
Command.Builder builder = manager.commandBuilder(
commandToken,
tokens.get(commandToken).getMinor(),
metaBuilder.build()
);
final Collection<ArgumentParameterPair> arguments = this.argumentExtractor.apply(method);
final Collection<CommandFlag<?>> flags = this.flagExtractor.apply(method);
final Map<String, CommandArgument<C, ?>> commandArguments = new HashMap<>();
final Map<CommandArgument<C, ?>, String> argumentDescriptions = new HashMap<>();
/* Go through all annotated parameters and build up the argument tree */
for (final ArgumentParameterPair argumentPair : arguments) {
final CommandArgument<C, ?> argument = this.buildArgument(method,
tokens.get(argumentPair.getArgument().value()),
argumentPair);
final CommandArgument<C, ?> argument = this.buildArgument(
method,
tokens.get(argumentPair.getArgument().value()),
argumentPair
);
commandArguments.put(argument.getName(), argument);
argumentDescriptions.put(argument, argumentPair.getArgument().description());
}
@ -209,9 +220,9 @@ public final class AnnotationParser<C> {
}
if (commandMethod.requiredSender() != Object.class) {
builder = builder.withSenderType(commandMethod.requiredSender());
builder = builder.senderType(commandMethod.requiredSender());
} else if (senderType != null) {
builder = builder.withSenderType(senderType);
builder = builder.senderType(senderType);
}
try {
/* Construct the handler */
@ -240,7 +251,7 @@ public final class AnnotationParser<C> {
throw new IllegalArgumentException("@ProxiedBy proxies may only contain single literals");
}
Command.Builder<C> proxyBuilder = manager.commandBuilder(proxy, builtCommand.getCommandMeta())
.proxies(builtCommand);
.proxies(builtCommand);
if (proxyAnnotation.hidden()) {
proxyBuilder = proxyBuilder.hidden();
}
@ -251,34 +262,38 @@ public final class AnnotationParser<C> {
}
@SuppressWarnings("unchecked")
private @NonNull CommandArgument<C, ?> buildArgument(final @NonNull Method method,
final @Nullable SyntaxFragment syntaxFragment,
final @NonNull ArgumentParameterPair argumentPair) {
private @NonNull CommandArgument<C, ?> buildArgument(
final @NonNull Method method,
final @Nullable SyntaxFragment syntaxFragment,
final @NonNull ArgumentParameterPair argumentPair
) {
final Parameter parameter = argumentPair.getParameter();
final Collection<Annotation> annotations = Arrays.asList(parameter.getAnnotations());
final TypeToken<?> token = TypeToken.get(parameter.getParameterizedType());
final ParserParameters parameters = this.manager.getParserRegistry()
.parseAnnotations(token, annotations);
.parseAnnotations(token, annotations);
final ArgumentParser<C, ?> parser;
if (argumentPair.getArgument().parserName().isEmpty()) {
parser = this.manager.getParserRegistry()
.createParser(token, parameters)
.orElseThrow(() -> new IllegalArgumentException(
String.format("Parameter '%s' in method '%s' "
+ "has parser '%s' but no parser exists "
+ "for that type",
parameter.getName(), method.getName(),
token.toString())));
.createParser(token, parameters)
.orElseThrow(() -> new IllegalArgumentException(
String.format("Parameter '%s' in method '%s' "
+ "has parser '%s' but no parser exists "
+ "for that type",
parameter.getName(), method.getName(),
token.toString()
)));
} else {
parser = this.manager.getParserRegistry()
.createParser(argumentPair.getArgument().parserName(), parameters)
.orElseThrow(() -> new IllegalArgumentException(
String.format("Parameter '%s' in method '%s' "
+ "has parser '%s' but no parser exists "
+ "for that type",
parameter.getName(), method.getName(),
token.toString())));
.createParser(argumentPair.getArgument().parserName(), parameters)
.orElseThrow(() -> new IllegalArgumentException(
String.format("Parameter '%s' in method '%s' "
+ "has parser '%s' but no parser exists "
+ "for that type",
parameter.getName(), method.getName(),
token.toString()
)));
}
if (syntaxFragment == null || syntaxFragment.getArgumentMode() == ArgumentMode.LITERAL) {
@ -287,8 +302,10 @@ public final class AnnotationParser<C> {
+ "Missing syntax mapping", argumentPair.getArgument().value(), method.getName()));
}
final Argument argument = argumentPair.getArgument();
@SuppressWarnings("ALL") final CommandArgument.Builder argumentBuilder = CommandArgument.ofType(parameter.getType(),
argument.value());
@SuppressWarnings("ALL") final CommandArgument.Builder argumentBuilder = CommandArgument.ofType(
parameter.getType(),
argument.value()
);
if (syntaxFragment.getArgumentMode() == ArgumentMode.OPTIONAL) {
if (argument.defaultValue().isEmpty()) {
argumentBuilder.asOptional();

6
cloud-annotations/src/main/java/cloud/commandframework/annotations/ArgumentParameterPair.java
View file

@ -32,8 +32,10 @@ final class ArgumentParameterPair {
private final Parameter parameter;
private final Argument argument;
ArgumentParameterPair(final @NonNull Parameter parameter,
final @NonNull Argument argument) {
ArgumentParameterPair(
final @NonNull Parameter parameter,
final @NonNull Argument argument
) {
this.parameter = parameter;
this.argument = argument;
}

6
cloud-annotations/src/main/java/cloud/commandframework/annotations/CommandMethodPair.java
View file

@ -32,8 +32,10 @@ final class CommandMethodPair {
private final Method method;
private final CommandMethod commandMethod;
CommandMethodPair(final @NonNull Method method,
final @NonNull CommandMethod commandMethod) {
CommandMethodPair(
final @NonNull Method method,
final @NonNull CommandMethod commandMethod
) {
this.method = method;
this.commandMethod = commandMethod;
}

1
cloud-annotations/src/main/java/cloud/commandframework/annotations/Confirmation.java
View file

@ -34,4 +34,5 @@ import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Confirmation {
}

24
cloud-annotations/src/main/java/cloud/commandframework/annotations/FlagExtractor.java
View file

@ -55,8 +55,10 @@ final class FlagExtractor implements Function<@NonNull Method, Collection<@NonNu
continue;
}
final Flag flag = parameter.getAnnotation(Flag.class);
final CommandFlag.Builder<Void> builder = this.commandManager.flagBuilder(flag.value())
.withDescription(Description.of(flag.description())).withAliases(flag.aliases());
final CommandFlag.Builder<Void> builder = this.commandManager
.flagBuilder(flag.value())
.withDescription(Description.of(flag.description()))
.withAliases(flag.aliases());
if (parameter.getType().equals(boolean.class)) {
flags.add(builder.build());
} else {
@ -72,15 +74,17 @@ final class FlagExtractor implements Function<@NonNull Method, Collection<@NonNu
if (parser == null) {
throw new IllegalArgumentException(
String.format("Cannot find parser for type '%s' for flag '%s' in method '%s'",
parameter.getType().getCanonicalName(), flag.value(), method.getName()));
parameter.getType().getCanonicalName(), flag.value(), method.getName()
));
}
@SuppressWarnings("ALL")
final CommandArgument.Builder argumentBuilder = CommandArgument.ofType(parameter.getType(), flag.value());
@SuppressWarnings("ALL")
final CommandArgument argument = argumentBuilder.asRequired()
.manager(this.commandManager)
.withParser(parser)
.build();
@SuppressWarnings("ALL") final CommandArgument.Builder argumentBuilder = CommandArgument.ofType(
parameter.getType(),
flag.value()
);
@SuppressWarnings("ALL") final CommandArgument argument = argumentBuilder.asRequired()
.manager(this.commandManager)
.withParser(parser)
.build();
// noinspection unchecked
flags.add(builder.withArgument(argument).build());
}

1
cloud-annotations/src/main/java/cloud/commandframework/annotations/Hidden.java
View file

@ -36,4 +36,5 @@ import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Hidden {
}

8
cloud-annotations/src/main/java/cloud/commandframework/annotations/MetaFactory.java
View file

@ -35,8 +35,10 @@ class MetaFactory implements Function<@NonNull Annotation @NonNull [], @NonNull
private final AnnotationParser<?> annotationParser;
private final Function<ParserParameters, CommandMeta> metaMapper;
MetaFactory(final @NonNull AnnotationParser<?> annotationParser,
final @NonNull Function<@NonNull ParserParameters, @NonNull CommandMeta> metaMapper) {
MetaFactory(
final @NonNull AnnotationParser<?> annotationParser,
final @NonNull Function<@NonNull ParserParameters, @NonNull CommandMeta> metaMapper
) {
this.annotationParser = annotationParser;
this.metaMapper = metaMapper;
}
@ -46,7 +48,7 @@ class MetaFactory implements Function<@NonNull Annotation @NonNull [], @NonNull
final ParserParameters parameters = ParserParameters.empty();
for (final Annotation annotation : annotations) {
@SuppressWarnings("ALL") final Function function = this.annotationParser.getAnnotationMappers()
.get(annotation.annotationType());
.get(annotation.annotationType());
if (function == null) {
continue;
}

10
cloud-annotations/src/main/java/cloud/commandframework/annotations/MethodCommandExecutionHandler.java
View file

@ -43,10 +43,12 @@ class MethodCommandExecutionHandler<C> implements CommandExecutionHandler<C> {
private final MethodHandle methodHandle;
private final Map<String, CommandArgument<C, ?>> commandArguments;
MethodCommandExecutionHandler(final @NonNull Object instance,
final @NonNull Map<@NonNull String,
@NonNull CommandArgument<@NonNull C, @NonNull ?>> commandArguments,
@NonNull final Method method) throws Exception {
MethodCommandExecutionHandler(
final @NonNull Object instance,
final @NonNull Map<@NonNull String,
@NonNull CommandArgument<@NonNull C, @NonNull ?>> commandArguments,
@NonNull final Method method
) throws Exception {
this.commandArguments = commandArguments;
method.setAccessible(true);
this.methodHandle = MethodHandles.lookup().unreflect(method).bindTo(instance);

8
cloud-annotations/src/main/java/cloud/commandframework/annotations/SyntaxFragment.java
View file

@ -33,9 +33,11 @@ final class SyntaxFragment {
private final List<String> minor;
private final ArgumentMode argumentMode;
SyntaxFragment(final @NonNull String major,
final @NonNull List<@NonNull String> minor,
final @NonNull ArgumentMode argumentMode) {
SyntaxFragment(
final @NonNull String major,
final @NonNull List<@NonNull String> minor,
final @NonNull ArgumentMode argumentMode
) {
this.major = major;
this.minor = minor;
this.argumentMode = argumentMode;

6
cloud-annotations/src/main/java/cloud/commandframework/annotations/SyntaxParser.java
View file

@ -40,11 +40,11 @@ import java.util.regex.Pattern;
final class SyntaxParser implements Function<@NonNull String, @NonNull LinkedHashMap<@NonNull String, @NonNull SyntaxFragment>> {
private static final Predicate<String> PATTERN_ARGUMENT_LITERAL = Pattern.compile("([A-Za-z0-9]+)(|([A-Za-z0-9]+))*")
.asPredicate();
.asPredicate();
private static final Predicate<String> PATTERN_ARGUMENT_REQUIRED = Pattern.compile("<([A-Za-z0-9]+)>")
.asPredicate();
.asPredicate();
private static final Predicate<String> PATTERN_ARGUMENT_OPTIONAL = Pattern.compile("\\[([A-Za-z0-9]+)]")
.asPredicate();
.asPredicate();
@Override
public @NonNull LinkedHashMap<@NonNull String, @NonNull SyntaxFragment> apply(final @NonNull String syntax) {