private ParameterResolver findParameterResolver(MethodParameter methodParameter) { return parameterResolvers.stream().filter(pr -> pr.supports(methodParameter)).findFirst().get(); } }
private List<ParameterDescription> getParameterDescriptions(MethodTarget methodTarget) { return Utils.createMethodParameters(methodTarget.getMethod()) .flatMap(mp -> parameterResolvers.stream().filter(pr -> pr.supports(mp)).limit(1L) .flatMap(pr -> pr.describe(mp))) .collect(Collectors.toList()); }
/** * Verifies that we have at least one {@link ParameterResolver} that supports each of the * {@link MethodParameter}s in the method. */ private void validateParameterResolvers(MethodTarget methodTarget) { Utils.createMethodParameters(methodTarget.getMethod()) .forEach(parameter -> { parameterResolvers.stream() .filter(resolver -> resolver.supports(parameter)) .findFirst() .orElseThrow(() -> new ParameterResolverMissingException(parameter)); }); }
/** * Use all known {@link ParameterResolver}s to try to compute a value for each parameter * of the method to invoke. * @param method the method for which parameters should be computed * @param wordsForArgs the list of 'words' that should be converted to parameter values. * May include markers for passing parameters 'by name' * @return an array containing resolved parameter values, or {@link #UNRESOLVED} for * parameters that could not be resolved */ private Object[] resolveArgs(Method method, List<String> wordsForArgs) { List<MethodParameter> parameters = Utils.createMethodParameters(method).collect(Collectors.toList()); Object[] args = new Object[parameters.size()]; Arrays.fill(args, UNRESOLVED); for (ParameterResolver resolver : parameterResolvers) { for (int argIndex = 0; argIndex < args.length; argIndex++) { MethodParameter parameter = parameters.get(argIndex); if (args[argIndex] == UNRESOLVED && resolver.supports(parameter)) { args[argIndex] = resolver.resolve(parameter, wordsForArgs).resolvedValue(); } } } return args; }
/** * Gather completion proposals given some (incomplete) input the user has already typed * in. When and how this method is invoked is implementation specific and decided by the * actual user interface. */ public List<CompletionProposal> complete(CompletionContext context) { String prefix = context.upToCursor(); List<CompletionProposal> candidates = new ArrayList<>(); candidates.addAll(commandsStartingWith(prefix)); String best = findLongestCommand(prefix); if (best != null) { CompletionContext argsContext = context.drop(best.split(" ").length); // Try to complete arguments MethodTarget methodTarget = methodTargets.get(best); Method method = methodTarget.getMethod(); List<MethodParameter> parameters = Utils.createMethodParameters(method).collect(Collectors.toList()); for (ParameterResolver resolver : parameterResolvers) { for (int index = 0; index < parameters.size(); index++) { MethodParameter parameter = parameters.get(index); if (resolver.supports(parameter)) { resolver.complete(parameter, argsContext).stream().forEach(candidates::add); } } } } return candidates; }