Examples with TargetIdeInfo com.google.idea.blaze.base.ideinfo.TargetIdeInfo used on opensource projects

Example 31 with TargetIdeInfo

use of com.google.idea.blaze.base.ideinfo.TargetIdeInfo in project intellij by bazelbuild.

the class BlazeAndroidWorkspaceImporter method createAarLibraries.

private ImmutableList<AarLibrary> createAarLibraries(Iterable<TargetIdeInfo> libraryTargets) {
    ImmutableList.Builder<AarLibrary> builder = ImmutableList.builder();
    for (TargetIdeInfo target : libraryTargets) {
        // don't have the equivalent of jdeps data.
        if (target.androidAarIdeInfo == null || target.javaIdeInfo == null || target.javaIdeInfo.jars.isEmpty()) {
            continue;
        }
        // aar_import should only have one jar (a merged jar from the AAR's jars).
        LibraryArtifact firstJar = target.javaIdeInfo.jars.iterator().next();
        builder.add(new AarLibrary(firstJar, target.androidAarIdeInfo.aar));
    }
    return builder.build();
}

Example 32 with TargetIdeInfo

use of com.google.idea.blaze.base.ideinfo.TargetIdeInfo in project intellij by bazelbuild.

the class BlazeAndroidWorkspaceImporter method importWorkspace.

public BlazeAndroidImportResult importWorkspace() {
    List<TargetIdeInfo> sourceTargets = targetMap.targets().stream().filter(target -> target.kind.languageClass == LanguageClass.ANDROID).filter(target -> target.androidIdeInfo != null).filter(importFilter::isSourceTarget).filter(target -> !importFilter.excludeTarget(target)).collect(Collectors.toList());
    TransitiveResourceMap transitiveResourceMap = new TransitiveResourceMap(targetMap);
    WorkspaceBuilder workspaceBuilder = new WorkspaceBuilder();
    for (TargetIdeInfo target : sourceTargets) {
        addSourceTarget(workspaceBuilder, transitiveResourceMap, target);
    }
    GeneratedResourceWarnings.submit(project, context, projectViewSet, artifactLocationDecoder, workspaceBuilder.generatedResourceLocations, whitelistedGenResourcePaths);
    ImmutableList<AndroidResourceModule> androidResourceModules = buildAndroidResourceModules(workspaceBuilder);
    BlazeResourceLibrary resourceLibrary = createResourceLibrary(androidResourceModules);
    ImmutableList<AarLibrary> aarLibraries = createAarLibraries(sourceFilter.getLibraryTargets());
    return new BlazeAndroidImportResult(androidResourceModules, resourceLibrary, aarLibraries, getJavacJar(targetMap.targets()));
}

Example 33 with TargetIdeInfo

use of com.google.idea.blaze.base.ideinfo.TargetIdeInfo in project intellij by bazelbuild.

the class BlazeAndroidProjectStructureSyncer method updateInMemoryState.

private static void updateInMemoryState(Project project, WorkspaceRoot workspaceRoot, ProjectViewSet projectViewSet, BlazeProjectData blazeProjectData, Module workspaceModule, AndroidResourceModuleRegistry registry, LightResourceClassService.Builder rClassBuilder) {
    BlazeAndroidSyncData syncData = blazeProjectData.syncState.get(BlazeAndroidSyncData.class);
    if (syncData == null) {
        return;
    }
    AndroidSdkPlatform androidSdkPlatform = syncData.androidSdkPlatform;
    if (androidSdkPlatform == null) {
        return;
    }
    updateWorkspaceModuleFacetInMemoryState(project, workspaceRoot, workspaceModule, androidSdkPlatform);
    ArtifactLocationDecoder artifactLocationDecoder = blazeProjectData.artifactLocationDecoder;
    ModuleFinder moduleFinder = ModuleFinder.getInstance(project);
    Executor resourceRepositoryExecutor = Executors.newSingleThreadExecutor();
    Module libraryResourcesModule = moduleFinder.findModuleByName(LIBRARY_RESOURCES_MODULE_NAME);
    if (libraryResourcesModule != null) {
        updateLibraryResourcesModuleFacetInMemoryState(project, workspaceRoot, libraryResourcesModule, androidSdkPlatform, syncData.importResult.resourceLibrary == null ? ImmutableList.of() : artifactLocationDecoder.decodeAll(syncData.importResult.resourceLibrary.sources), resourceRepositoryExecutor);
    } else if (useLibraryResourcesModule.getValue()) {
        logger.warn("Library resources module missing.");
    }
    for (AndroidResourceModule androidResourceModule : syncData.importResult.androidResourceModules) {
        TargetIdeInfo target = blazeProjectData.targetMap.get(androidResourceModule.targetKey);
        String moduleName = moduleNameForAndroidModule(target.key);
        Module module = moduleFinder.findModuleByName(moduleName);
        if (module == null) {
            logger.warn("No module found for resource target: " + target.key);
            continue;
        }
        registry.put(module, androidResourceModule);
        AndroidIdeInfo androidIdeInfo = target.androidIdeInfo;
        assert androidIdeInfo != null;
        updateModuleFacetInMemoryState(project, androidSdkPlatform, module, moduleDirectoryForAndroidTarget(workspaceRoot, target), manifestFileForAndroidTarget(artifactLocationDecoder, androidIdeInfo, moduleDirectoryForAndroidTarget(workspaceRoot, target)), androidIdeInfo.resourceJavaPackage, artifactLocationDecoder.decodeAll(useLibraryResourcesModule.getValue() ? androidResourceModule.resources : androidResourceModule.transitiveResources), resourceRepositoryExecutor);
        rClassBuilder.addRClass(androidIdeInfo.resourceJavaPackage, module);
    }
    Set<TargetKey> androidResourceModules = syncData.importResult.androidResourceModules.stream().map(androidResourceModule -> androidResourceModule.targetKey).collect(toSet());
    List<TargetIdeInfo> runConfigurationTargets = getRunConfigurationTargets(project, projectViewSet, blazeProjectData, androidResourceModules);
    for (TargetIdeInfo target : runConfigurationTargets) {
        String moduleName = moduleNameForAndroidModule(target.key);
        Module module = moduleFinder.findModuleByName(moduleName);
        if (module == null) {
            logger.warn("No module found for run configuration target: " + target.key);
            continue;
        }
        AndroidIdeInfo androidIdeInfo = target.androidIdeInfo;
        assert androidIdeInfo != null;
        updateModuleFacetInMemoryState(project, androidSdkPlatform, module, moduleDirectoryForAndroidTarget(workspaceRoot, target), manifestFileForAndroidTarget(artifactLocationDecoder, androidIdeInfo, moduleDirectoryForAndroidTarget(workspaceRoot, target)), androidIdeInfo.resourceJavaPackage, ImmutableList.of(), null);
    }
}

Example 34 with TargetIdeInfo

use of com.google.idea.blaze.base.ideinfo.TargetIdeInfo in project intellij by bazelbuild.

the class BlazeAndroidProjectStructureSyncer method updateProjectStructure.

public static void updateProjectStructure(Project project, BlazeContext context, ProjectViewSet projectViewSet, BlazeProjectData blazeProjectData, BlazeSyncPlugin.ModuleEditor moduleEditor, Module workspaceModule, ModifiableRootModel workspaceModifiableModel, boolean isAndroidWorkspace) {
    if (!isAndroidWorkspace) {
        AndroidFacetModuleCustomizer.removeAndroidFacet(workspaceModule);
        return;
    }
    BlazeAndroidSyncData syncData = blazeProjectData.syncState.get(BlazeAndroidSyncData.class);
    if (syncData == null) {
        return;
    }
    AndroidSdkPlatform androidSdkPlatform = syncData.androidSdkPlatform;
    if (androidSdkPlatform == null) {
        return;
    }
    // Configure workspace module as an android module
    AndroidFacetModuleCustomizer.createAndroidFacet(workspaceModule);
    Module libraryResourcesModule = null;
    if (useLibraryResourcesModule.getValue()) {
        libraryResourcesModule = moduleEditor.createModule(LIBRARY_RESOURCES_MODULE_NAME, StdModuleTypes.JAVA);
        AndroidFacetModuleCustomizer.createAndroidFacet(libraryResourcesModule);
    }
    // Create android resource modules
    // Because we're setting up dependencies, the modules have to exist before we configure them
    Map<TargetKey, AndroidResourceModule> targetToAndroidResourceModule = Maps.newHashMap();
    for (AndroidResourceModule androidResourceModule : syncData.importResult.androidResourceModules) {
        targetToAndroidResourceModule.put(androidResourceModule.targetKey, androidResourceModule);
        String moduleName = moduleNameForAndroidModule(androidResourceModule.targetKey);
        Module module = moduleEditor.createModule(moduleName, StdModuleTypes.JAVA);
        AndroidFacetModuleCustomizer.createAndroidFacet(module);
    }
    // Configure android resource modules
    int totalOrderEntries = 0;
    Set<File> existingRoots = Sets.newHashSet();
    for (AndroidResourceModule androidResourceModule : targetToAndroidResourceModule.values()) {
        TargetIdeInfo target = blazeProjectData.targetMap.get(androidResourceModule.targetKey);
        AndroidIdeInfo androidIdeInfo = target.androidIdeInfo;
        assert androidIdeInfo != null;
        String moduleName = moduleNameForAndroidModule(target.key);
        Module module = moduleEditor.findModule(moduleName);
        assert module != null;
        ModifiableRootModel modifiableRootModel = moduleEditor.editModule(module);
        Collection<File> resources = blazeProjectData.artifactLocationDecoder.decodeAll(androidResourceModule.resources);
        if (useCyclicResourceDependency.getValue()) {
            // Remove existing resource roots to silence the duplicate content root error.
            // We can only do this if we have cyclic resource dependencies, since otherwise we risk
            // breaking dependencies within this resource module.
            resources.removeAll(existingRoots);
            existingRoots.addAll(resources);
        }
        ResourceModuleContentRootCustomizer.setupContentRoots(modifiableRootModel, resources);
        if (useCyclicResourceDependency.getValue()) {
            modifiableRootModel.addModuleOrderEntry(workspaceModule);
            ++totalOrderEntries;
        } else {
            for (TargetKey resourceDependency : androidResourceModule.transitiveResourceDependencies) {
                if (!targetToAndroidResourceModule.containsKey(resourceDependency)) {
                    continue;
                }
                String dependencyModuleName = moduleNameForAndroidModule(resourceDependency);
                Module dependency = moduleEditor.findModule(dependencyModuleName);
                if (dependency == null) {
                    continue;
                }
                modifiableRootModel.addModuleOrderEntry(dependency);
                ++totalOrderEntries;
            }
        }
        if (libraryResourcesModule != null) {
            // Add a dependency from the resource module to the shared library resources module
            modifiableRootModel.addModuleOrderEntry(libraryResourcesModule);
            ++totalOrderEntries;
        }
        // Add a dependency from the workspace to the resource module
        ModuleOrderEntry orderEntry = workspaceModifiableModel.addModuleOrderEntry(module);
        ++totalOrderEntries;
        if (useCyclicResourceDependency.getValue()) {
            orderEntry.setExported(true);
        }
    }
    List<TargetIdeInfo> runConfigurationTargets = getRunConfigurationTargets(project, projectViewSet, blazeProjectData, targetToAndroidResourceModule.keySet());
    for (TargetIdeInfo target : runConfigurationTargets) {
        TargetKey targetKey = target.key;
        String moduleName = moduleNameForAndroidModule(targetKey);
        Module module = moduleEditor.createModule(moduleName, StdModuleTypes.JAVA);
        AndroidFacetModuleCustomizer.createAndroidFacet(module);
    }
    int whitelistedGenResources = projectViewSet.listItems(GeneratedAndroidResourcesSection.KEY).size();
    context.output(PrintOutput.log(String.format("Android resource module count: %d, run config modules: %d, order entries: %d, " + "generated resources: %d", syncData.importResult.androidResourceModules.size(), runConfigurationTargets.size(), totalOrderEntries, whitelistedGenResources)));
}

Example 35 with TargetIdeInfo

use of com.google.idea.blaze.base.ideinfo.TargetIdeInfo in project intellij by bazelbuild.

the class TransitiveDependencyMap method getTransitiveDependencies.

public static ImmutableCollection<TargetKey> getTransitiveDependencies(Collection<TargetKey> targetKeys, TargetMap targetMap) {
    Queue<TargetKey> targetsToVisit = Queues.newArrayDeque();
    Set<TargetKey> transitiveDependencies = Sets.newHashSet();
    targetsToVisit.addAll(targetKeys);
    while (!targetsToVisit.isEmpty()) {
        TargetIdeInfo currentTarget = targetMap.get(targetsToVisit.remove());
        if (currentTarget == null) {
            continue;
        }
        List<TargetKey> newDependencies = currentTarget.dependencies.stream().map(d -> TargetKey.forPlainTarget(d.targetKey.label)).filter(r -> !transitiveDependencies.contains(r)).collect(Collectors.toList());
        targetsToVisit.addAll(newDependencies);
        transitiveDependencies.addAll(newDependencies);
    }
    return ImmutableSet.copyOf(transitiveDependencies);
}