private Map<String, String> getContainerParameterNames(List<ParameterDeclaration> allParameters) { Map<String, String> parameterNames = new HashMap<>(); for (ParameterDeclaration parameterDeclaration : allParameters) { parameterNames.put(getImplementingName(parameterDeclaration), parameterDeclaration.getName()); } return parameterNames; } }
/** * Given a component declaration, adds all the stereotypes accepted by the config-ref parameter if it has one. */ private void addConfigRefStereoTypesIfNeeded(ComponentDeclaration<?> declaration) { Collection<ConfigurationDeclaration> configs = componentConfigs.get(declaration); if (configs != null && !configs.isEmpty()) { List<StereotypeModel> stereotypes = configs.stream().map(StereotypedDeclaration::getStereotype).collect(toList()); declaration.getAllParameters().stream() .filter(p -> CONFIG_ATTRIBUTE_NAME.equals(p.getName())) .findAny() .ifPresent(configRef -> configRef.setAllowedStereotypeModels(stereotypes)); } } }
private List<StereotypeModel> findStereotypes(ComponentModel componentModel, ParameterDeclaration propertyDeclaration) { final String expectedPropertyReference = ExpressionManager.DEFAULT_EXPRESSION_PREFIX + BindingContextUtils.VARS + "." + propertyDeclaration.getName() + ExpressionManager.DEFAULT_EXPRESSION_POSTFIX; return componentModel.getParameters().entrySet().stream() .filter(stringStringEntry -> stringStringEntry.getValue().equals(expectedPropertyReference)) .map(Map.Entry::getKey) .map(attributeName -> findStereotypes(componentModel.getIdentifier(), attributeName)) .flatMap(Collection::stream) .collect(Collectors.toList()); }
private void declareInputResolvers(ComponentDeclaration<?> declaration, MetadataScopeAdapter metadataScope) { if (metadataScope.hasInputResolvers()) { Set<String> dynamicParameters = metadataScope.getInputResolvers().keySet(); declaration.getAllParameters().stream() .filter(p -> dynamicParameters.contains(p.getName())) .forEach(this::declareDynamicType); } }
public static Optional<Field> getField(Class<?> clazz, ParameterDeclaration parameterDeclaration, ReflectionCache reflectionCache) { return getField(clazz, MuleExtensionAnnotationParser.getMemberName(parameterDeclaration, parameterDeclaration.getName()), reflectionCache); }
private Optional<MetadataKeyIdModelProperty> findMetadataKeyIdInParameters( ComponentDeclaration<? extends ComponentDeclaration> component, String categoryName) { return component.getParameterGroups().stream() .flatMap(g -> g.getParameters().stream()) .filter(p -> getExtensionParameter(p).map(element -> element.isAnnotatedWith(MetadataKeyId.class)).orElse(false)) .map(p -> new MetadataKeyIdModelProperty(p.getType(), p.getName(), categoryName)) .findFirst(); }
private void validateExpressionSupport(ConnectionProviderDeclaration provider, ParameterDeclaration parameter, Field field) { Expression expression = field.getAnnotation(Expression.class); if (expression != null && expression.value() != NOT_SUPPORTED) { throw new IllegalConnectionProviderModelDefinitionException( format( "Parameter '%s' in Connection Provider '%s' is marked as supporting expressions. Expressions are not supported " + "in OAuth parameters", parameter.getName(), provider.getName())); } }
void document(ParameterizedDeclaration<?> parameterized, final TypeElement element) { TypeElement traversingElement = element; while (traversingElement != null && !Object.class.getName().equals(traversingElement.getQualifiedName().toString())) { final Map<String, VariableElement> variableElements = processor.getFieldsAnnotatedWith(traversingElement, Parameter.class) .entrySet() .stream() .collect(Collectors.toMap(entry -> getNameOrAlias(entry.getValue()), Map.Entry::getValue)); parameterized.getAllParameters() .stream().filter(param -> variableElements.containsKey(param.getName())) .forEach(param -> { String summary = processor.getJavaDocSummary(processingEnv, variableElements.get(param.getName())); param.setDescription(summary); }); traversingElement = (TypeElement) processingEnv.getTypeUtils().asElement(traversingElement.getSuperclass()); } for (VariableElement variableElement : processor.getFieldsAnnotatedWith(element, ParameterGroup.class) .values()) { TypeElement typeElement = (TypeElement) processingEnv.getTypeUtils().asElement(variableElement.asType()); document(parameterized, typeElement); } } }
private void document(ParameterizedDeclaration<?> declaration, List<XmlExtensionElementDocumentation> elements) { elements.stream().filter(e -> e.getName().equals(declaration.getName())).findAny() .ifPresent(e -> { declaration.setDescription(e.getDescription()); declaration.getAllParameters() .forEach(param -> e.getParameters().stream().filter(p -> p.getName().equals(param.getName())).findAny() .ifPresent(p -> param.setDescription(p.getDescription()))); }); } }.walk(declaration);
/** * Describes parameters that are defined as Method parameters. */ void document(ParameterizedDeclaration<?> parameterized, Element method, MethodDocumentation documentation) { parameterized.getAllParameters().forEach(p -> { String description = documentation.getParameters().get(p.getName()); if (description != null) { p.setDescription(description); } }); if (method instanceof ExecutableElement) { ((ExecutableElement) method).getParameters().stream() .filter(e -> e.getAnnotation(ParameterGroup.class) != null) .forEach(group -> { TypeElement typeElement = (TypeElement) processingEnv.getTypeUtils().asElement(group.asType()); document(parameterized, typeElement); }); } }
/** * Resolves the original name of a parameter before it was modified due to the usage of an Alias. * * @param parameterDeclaration parameter from which look for their original name * @return the original name */ public static String getImplementingName(ParameterDeclaration parameterDeclaration) { return getImplementingName(parameterDeclaration.getName(), () -> parameterDeclaration.getModelProperty(ImplementingParameterModelProperty.class), () -> parameterDeclaration.getModelProperty(DeclaringMemberModelProperty.class)); }
private ParameterDeclaration findParameter(List<ParameterDeclaration> parameters, final String name) { return (ParameterDeclaration) find(parameters, object -> name.equals(((ParameterDeclaration) object).getName())); } }
protected ParameterDeclaration findParameter(List<ParameterDeclaration> parameters, final String name) { return (ParameterDeclaration) find(parameters, object -> name.equals(((ParameterDeclaration) object).getName())); }
@Before public void setUp() { when(loadingContext.getExtensionDeclarer().getDeclaration()).thenReturn(declaration); when(declaration.getConnectionProviders()).thenReturn(singletonList(connectionProviderDeclaration)); when(declaration.getConfigurations()).thenReturn(singletonList(configurationDeclaration)); ExtensionParameterDescriptorModelProperty descriptorModelProperty = mock(ExtensionParameterDescriptorModelProperty.class); when(parameterDeclaration.getModelProperty(ExtensionParameterDescriptorModelProperty.class)) .thenReturn(Optional.of(descriptorModelProperty)); when(parameterDeclaration.getName()).thenReturn(REQUIRED_PARAM); when(descriptorModelProperty.getExtensionParameter()).thenReturn(extensionParameter); }
public DefaultMetadataScopeAdapter(Type extensionElement, MethodElement operation, OperationDeclaration declaration) { operation.getValueFromAnnotation(OutputResolver.class); Optional<OutputResolver> outputResolverDeclaration = operation.getAnnotation(OutputResolver.class); Optional<Pair<MetadataKeyId, MetadataType>> keyId = locateMetadataKeyId(declaration); inputResolvers = declaration.getAllParameters().stream() .filter(p -> getAnnotatedElement(p).map(e -> e.isAnnotationPresent(TypeResolver.class)).orElse(false)) .filter(p -> !hasCustomStaticType(p)) .collect(toMap(p -> p.getName(), p -> ResolverSupplier.of(getAnnotatedElement(p).get().getAnnotation(TypeResolver.class).value()))); if (outputResolverDeclaration.isPresent() || !inputResolvers.isEmpty()) { outputResolverDeclaration.ifPresent(resolverDeclaration -> { if (!hasCustomStaticType(declaration.getOutput())) { outputResolver = ResolverSupplier.of(resolverDeclaration.output()); } if (!hasCustomStaticType(declaration.getOutputAttributes())) { attributesResolver = ResolverSupplier.of(resolverDeclaration.attributes()); } }); keyId.ifPresent(pair -> keysResolver = getKeysResolver(pair.getRight(), pair.getLeft(), () -> getCategoryName(outputResolver, attributesResolver, inputResolvers))); } else { initializeFromClass(extensionElement, operation, declaration); } }
private void assertEnrichment(boolean runsOnPrimaryNodeOnly, boolean parameterAdded, boolean defaultParameterValue) { enricher.enrich(extensionLoadingContext); verify(sourceDeclaration).setRunsOnPrimaryNodeOnly(runsOnPrimaryNodeOnly); if (parameterAdded) { ArgumentCaptor<ParameterDeclaration> captor = ArgumentCaptor.forClass(ParameterDeclaration.class); verify(parameterGroup).addParameter(captor.capture()); ParameterDeclaration parameter = captor.getValue(); assertThat(parameter.getName(), equalTo(PRIMARY_NODE_ONLY_PARAMETER_NAME)); assertThat(parameter.getDefaultValue(), is(defaultParameterValue)); } else { verify(parameterGroup, never()).addParameter(any()); } }
@Test public void verifyTargetValueParameterOnOperation() { OperationDeclaration operationDeclaration = getNamedObject(declaration.getOperations(), "transform"); ParameterDeclaration parameterDeclaration = getNamedObject(operationDeclaration.getAllParameters(), "targetValue"); assertThat(parameterDeclaration.getName(), is("targetValue")); assertThat(parameterDeclaration.getExpressionSupport(), is(REQUIRED)); assertThat(parameterDeclaration.getType(), instanceOf(StringType.class)); assertThat(parameterDeclaration.isRequired(), is(false)); }
@Test public void verifyTargetParameterOnOperation() { OperationDeclaration operationDeclaration = getNamedObject(declaration.getOperations(), "transform"); ParameterDeclaration parameterDeclaration = getNamedObject(operationDeclaration.getAllParameters(), "target"); assertThat(parameterDeclaration.getName(), is("target")); assertThat(parameterDeclaration.getExpressionSupport(), is(NOT_SUPPORTED)); assertThat(parameterDeclaration.getType(), instanceOf(StringType.class)); assertThat(parameterDeclaration.isRequired(), is(false)); }
private void assertParameter(ParameterDeclaration parameter, String name) { assertThat(parameter, is(notNullValue())); assertThat(parameter.getName(), is(name)); assertThat(parameter.getType(), equalTo(toMetadataType(String.class))); assertThat(parameter.isRequired(), is(false)); assertThat(parameter.getExpressionSupport(), is(SUPPORTED)); assertThat(parameter.getDefaultValue(), is(nullValue())); }
private void assertParameter(List<ParameterDeclaration> parameters, String name, String description, MetadataType metadataType, boolean required, ExpressionSupport expressionSupport, Object defaultValue) { ParameterDeclaration param = findParameter(parameters, name); assertThat(param, is(notNullValue())); assertThat(param.getName(), equalTo(name)); assertThat(param.getDescription(), equalTo(description)); assertParameterType(metadataType, param); assertThat(param.isRequired(), is(required)); assertThat(param.getExpressionSupport(), is(expressionSupport)); assertThat(param.getDefaultValue(), equalTo(defaultValue)); }