Examples with LogicalPath org.springframework.roo.project.LogicalPath used on opensource projects

Example 16 with LogicalPath

use of org.springframework.roo.project.LogicalPath in project spring-roo by spring-projects.

the class ApplicationConfigServiceImpl method getApplicationConfigFileLocation.

/**
 * Method that get application config file location
 *
 * @return Path where application config file is located
 */
private LogicalPath getApplicationConfigFileLocation(String moduleName) {
    Validate.notNull(moduleName, "Module name is required");
    LogicalPath location = LogicalPath.getInstance(DEFAULT_APPLICATION_CONFIG_FILE_LOCATION, moduleName);
    // ROO-3706: Check if exists some specific configuration to the
    // location of application config properties file
    String fileLocationShellConfig = settingsService.getProperty(CONFIG_FILE_LOCATION_SHELL_PROPERTY);
    if (fileLocationShellConfig != null && StringUtils.isNotBlank(fileLocationShellConfig)) {
        location = LogicalPath.getInstance(Path.ROOT, fileLocationShellConfig);
    }
    return location;
}

Example 17 with LogicalPath

use of org.springframework.roo.project.LogicalPath in project spring-roo by spring-projects.

the class JaxbEntityMetadataProviderImpl method getGovernorPhysicalTypeIdentifier.

@Override
protected String getGovernorPhysicalTypeIdentifier(final String metadataIdentificationString) {
    final JavaType javaType = JaxbEntityMetadata.getJavaType(metadataIdentificationString);
    final LogicalPath path = JaxbEntityMetadata.getPath(metadataIdentificationString);
    return PhysicalTypeIdentifier.createIdentifier(javaType, path);
}

Example 18 with LogicalPath

use of org.springframework.roo.project.LogicalPath in project spring-roo by spring-projects.

the class DefaultPhysicalTypeMetadataProvider method get.

public MetadataItem get(final String metadataIdentificationString) {
    if (fileManager == null) {
        fileManager = getFileManager();
    }
    Validate.notNull(fileManager, "FileManager is required");
    if (metadataDependencyRegistry == null) {
        metadataDependencyRegistry = getMetadataDependencyRegistry();
    }
    Validate.notNull(metadataDependencyRegistry, "MetadataDependencyRegistry is required");
    if (projectOperations == null) {
        projectOperations = getProjectOperations();
    }
    Validate.notNull(projectOperations, "ProjectOperations is required");
    if (typeLocationService == null) {
        typeLocationService = getTypeLocationService();
    }
    Validate.notNull(typeLocationService, "TypeLocationService is required");
    if (typeParsingService == null) {
        typeParsingService = getTypeParsingService();
    }
    Validate.notNull(typeParsingService, "TypeParsingService is required");
    Validate.isTrue(PhysicalTypeIdentifier.isValid(metadataIdentificationString), "Metadata id '%s' is not valid for this metadata provider", metadataIdentificationString);
    final String canonicalPath = typeLocationService.getPhysicalTypeCanonicalPath(metadataIdentificationString);
    if (StringUtils.isBlank(canonicalPath)) {
        return null;
    }
    metadataDependencyRegistry.deregisterDependencies(metadataIdentificationString);
    if (!fileManager.exists(canonicalPath)) {
        // that was found but could not be parsed
        return null;
    }
    final JavaType javaType = PhysicalTypeIdentifier.getJavaType(metadataIdentificationString);
    final ClassOrInterfaceTypeDetails typeDetails = typeParsingService.getTypeAtLocation(canonicalPath, metadataIdentificationString, javaType);
    if (typeDetails == null) {
        return null;
    }
    final PhysicalTypeMetadata result = new DefaultPhysicalTypeMetadata(metadataIdentificationString, canonicalPath, typeDetails);
    final ClassOrInterfaceTypeDetails details = result.getMemberHoldingTypeDetails();
    if (details != null && details.getPhysicalTypeCategory() == PhysicalTypeCategory.CLASS && details.getExtendsTypes().size() == 1) {
        // This is a class, and it extends another class
        if (details.getSuperclass() != null) {
            // We have a dependency on the superclass, and there is metadata
            // available for the superclass
            // We won't implement the full MetadataNotificationListener
            // here, but rely on MetadataService's fallback
            // (which is to evict from cache and call get again given
            // JavaParserMetadataProvider doesn't implement
            // MetadataNotificationListener, then notify everyone we've
            // changed)
            final String superclassId = details.getSuperclass().getDeclaredByMetadataId();
            metadataDependencyRegistry.registerDependency(superclassId, result.getId());
        } else {
            // type change, in the hope we discover our parent someday
            for (final LogicalPath sourcePath : projectOperations.getPathResolver().getSourcePaths()) {
                final String possibleSuperclass = PhysicalTypeIdentifier.createIdentifier(details.getExtendsTypes().get(0), sourcePath);
                metadataDependencyRegistry.registerDependency(possibleSuperclass, result.getId());
            }
        }
    }
    MemberDetails memberDetails = new MemberDetailsBuilder(Arrays.asList(details)).build();
    // Loop until such time as we complete a full loop where no changes are
    // made to the result
    boolean additionalLoopRequired = true;
    while (additionalLoopRequired) {
        additionalLoopRequired = false;
        for (final MemberDetailsDecorator decorator : decorators) {
            final MemberDetails newResult = decorator.decorateTypes(DefaultPhysicalTypeMetadataProvider.class.getName(), memberDetails);
            Validate.isTrue(newResult != null, "Decorator '%s' returned an illegal result", decorator.getClass().getName());
            if (!newResult.equals(memberDetails)) {
                additionalLoopRequired = true;
                memberDetails = newResult;
            }
        }
    }
    return new DefaultPhysicalTypeMetadata(metadataIdentificationString, canonicalPath, (ClassOrInterfaceTypeDetails) memberDetails.getDetails().get(0));
}

Example 19 with LogicalPath

use of org.springframework.roo.project.LogicalPath in project spring-roo by spring-projects.

the class TypeLocationServiceImpl method getPhysicalTypeCanonicalPath.

public String getPhysicalTypeCanonicalPath(final String physicalTypeId) {
    final LogicalPath logicalPath = PhysicalTypeIdentifier.getPath(physicalTypeId);
    final JavaType javaType = PhysicalTypeIdentifier.getJavaType(physicalTypeId);
    final Pom pom = getProjectOperations().getPomFromModuleName(logicalPath.getModule());
    final String canonicalFilePath = pom.getPathLocation(logicalPath.getPath()) + javaType.getRelativeFileName();
    if (getFileManager().exists(canonicalFilePath)) {
        getTypeCache().cacheTypeAgainstModule(pom, javaType);
        getTypeCache().cacheFilePathAgainstTypeIdentifier(canonicalFilePath, physicalTypeId);
    }
    return canonicalFilePath;
}

Example 20 with LogicalPath

use of org.springframework.roo.project.LogicalPath in project spring-roo by spring-projects.

the class TypeLocationServiceImpl method getPhysicalTypeIdentifier.

public String getPhysicalTypeIdentifier(final JavaType type) {
    final PhysicalPath containingPhysicalPath = getPhysicalPath(type);
    if (containingPhysicalPath == null) {
        return null;
    }
    final LogicalPath logicalPath = containingPhysicalPath.getLogicalPath();
    return PhysicalTypeIdentifier.createIdentifier(type, logicalPath);
}