Examples with ExternalProject org.eclipse.n4js.utils.resources.ExternalProject used on opensource projects

Example 1 with ExternalProject

use of org.eclipse.n4js.utils.resources.ExternalProject in project n4js by eclipse.

the class N4JSBuilderParticipant method getGeneratorMarkers.

@Override
protected Map<OutputConfiguration, Iterable<IMarker>> getGeneratorMarkers(IProject builtProject, Collection<OutputConfiguration> outputConfigurations) throws CoreException {
    if (builtProject instanceof ExternalProject) {
        return emptyMap();
    }
    Map<OutputConfiguration, Iterable<IMarker>> generatorMarkers = newHashMap();
    for (OutputConfiguration config : outputConfigurations) {
        if (config.isCleanUpDerivedResources()) {
            List<IMarker> markers = Lists.newArrayList();
            for (IContainer container : getOutputs(builtProject, config)) {
                Iterables.addAll(markers, getDerivedResourceMarkers().findDerivedResourceMarkers(container, getGeneratorIdProvider().getGeneratorIdentifier()));
            }
            generatorMarkers.put(config, markers);
        }
    }
    return generatorMarkers;
}

Example 2 with ExternalProject

use of org.eclipse.n4js.utils.resources.ExternalProject in project n4js by eclipse.

the class N4JSProjectExplorerHelper method getProject.

/**
 * Returns with the corresponding {@link IN4JSProject N4JS project} for the given {@link IProject Eclipse project}
 * argument. Returns with {@code null} if
 * <ul>
 * <li>the {@code project} argument is {@code null} or</li>
 * <li>no {@link IN4JSProject#exists() existing} {@link IN4JSProject N4JS project} project can be found with the
 * desired project ID.</li>
 * </ul>
 *
 * @param project
 *            the searched project.
 * @return the N4JS project or {@code null} if such project does not exist.
 */
public IN4JSProject getProject(IProject project) {
    checkArgument(!(project instanceof ExternalProject), "Expected Eclipse workspace project. Got: " + project);
    if (null == project || !project.exists() || !project.isOpen()) {
        return null;
    }
    final String projectName = Strings.nullToEmpty(project.getName());
    final IN4JSProject n4Project = core.create(createPlatformResourceURI(projectName, true));
    if (null == n4Project || !n4Project.exists() || n4Project.isExternal()) {
        return null;
    }
    return n4Project;
}

Example 3 with ExternalProject

use of org.eclipse.n4js.utils.resources.ExternalProject in project n4js by eclipse.

the class N4JSProjectExplorerHelper method getVirtualNodesForProject.

/**
 * Returns with an array of virtual {@link Node node} instances for the project that should be revealed in the
 * project explorer.
 *
 * @param project
 *            the workspace project.
 * @return an array of virtual nodes.
 */
public Node[] getVirtualNodesForProject(IProject project) {
    checkArgument(!(project instanceof ExternalProject), "Expected Eclipse workspace project. Got: " + project);
    if (null == project || !project.exists() || !project.isAccessible()) {
        return Node.EMPTY_NODES;
    }
    IN4JSProject n4Project = getProject(project);
    if (null == n4Project || !n4Project.exists() || n4Project.isExternal()) {
        return Node.EMPTY_NODES;
    }
    final Image image = ImageRef.LIB_PATH.asImage().get();
    final NamedNode rootNode = new NamedNode(project, "External Dependencies", image);
    Iterable<IN4JSProject> directDependencies = from(n4Project.getAllDirectDependencies()).filter(IN4JSProject.class);
    Iterable<IN4JSProject> runtimeLibraries = getExternalDependenciesOfType(directDependencies, RUNTIME_LIBRARY);
    if (!from(runtimeLibraries).isEmpty()) {
        Map<String, IN4JSProject> builtInRuntimeEnvironments = getBuiltInRuntimeEnvironments();
        Map<String, IN4JSProject> builtInRuntimeLibraries = getBuiltInRuntimeLibraries();
        Collection<IN4JSProject> libs = newHashSet();
        Collection<IN4JSProject> envs = newHashSet();
        for (IN4JSProject p : runtimeLibraries) {
            IN4JSProject dependency = builtInRuntimeLibraries.get(p.getProjectId());
            if (null != dependency) {
                libs.add(dependency);
            }
        }
        if (!libs.isEmpty()) {
            OUTER: for (IN4JSProject p : builtInRuntimeEnvironments.values()) {
                for (IN4JSProject providedLib : from(p.getProvidedRuntimeLibraries()).filter(IN4JSProject.class)) {
                    if (libs.contains(providedLib)) {
                        envs.add(p);
                        String extndedRuntimeEnvName = p.getExtendedRuntimeEnvironmentId().orNull();
                        if (null != extndedRuntimeEnvName) {
                            final IN4JSProject extension = builtInRuntimeEnvironments.get(extndedRuntimeEnvName);
                            if (null != extension) {
                                envs.add(extension);
                            }
                        }
                        continue OUTER;
                    }
                }
            }
        }
        NamedNode runtimeNode = new NamedNode(rootNode, "N4JS Runtime", image);
        if (!envs.isEmpty()) {
            NamedNode envsNode = new NamedNode(runtimeNode, "Runtime Environments", image);
            envsNode.addChild(from(envs).transform(p -> new BuiltInProjectNode(envsNode, p)));
            runtimeNode.addChild(envsNode);
        }
        if (!libs.isEmpty()) {
            NamedNode libsNode = new NamedNode(runtimeNode, "Runtime Libraries", image);
            libsNode.addChild(from(libs).transform(p -> new BuiltInProjectNode(libsNode, p)));
            runtimeNode.addChild(libsNode);
        }
        if (!Arrays2.isEmpty(runtimeNode.getChildren())) {
            rootNode.addChild(runtimeNode);
        }
    }
    Map<String, IN4JSProject> langProjects = getAvailableLangProjects();
    Map<String, IN4JSProject> mangelhaftProjects = getAvailableMangelhaftProjects();
    Map<String, IN4JSProject> npmProjects = getAvailableNpmProjects();
    Collection<IN4JSProject> requiredLangLibs = newHashSet();
    Collection<IN4JSProject> requiredMangelhaftLibs = newHashSet();
    Collection<IN4JSProject> requiredNpmLibs = newHashSet();
    for (IN4JSProject directDependecy : directDependencies) {
        if (directDependecy.exists() && directDependecy.isExternal()) {
            IN4JSProject externalDepenency = mangelhaftProjects.get(directDependecy.getProjectId());
            if (null != externalDepenency) {
                requiredMangelhaftLibs.add(externalDepenency);
            } else {
                externalDepenency = npmProjects.get(directDependecy.getProjectId());
                if (null != externalDepenency) {
                    requiredNpmLibs.add(externalDepenency);
                } else {
                    externalDepenency = langProjects.get(directDependecy.getProjectId());
                    if (null != externalDepenency) {
                        requiredLangLibs.add(externalDepenency);
                    }
                }
            }
        }
    }
    if (!requiredLangLibs.isEmpty()) {
        NamedNode langNode = new NamedNode(rootNode, EXTERNAL_LIBRARY_NAMES.get(LANG_CATEGORY), image);
        langNode.addChild(from(requiredLangLibs).transform(p -> new BuiltInProjectNode(langNode, p)));
        rootNode.addChild(langNode);
    }
    if (!requiredMangelhaftLibs.isEmpty()) {
        NamedNode mangNode = new NamedNode(rootNode, EXTERNAL_LIBRARY_NAMES.get(MANGELHAFT_CATEGORY), image);
        mangNode.addChild(from(requiredMangelhaftLibs).transform(p -> new BuiltInProjectNode(mangNode, p)));
        rootNode.addChild(mangNode);
    }
    if (!requiredNpmLibs.isEmpty()) {
        NamedNode npmNode = new NamedNode(rootNode, EXTERNAL_LIBRARY_NAMES.get(NPM_CATEGORY), image);
        npmNode.addChild(from(requiredNpmLibs).transform(p -> new BuiltInProjectNode(npmNode, p)));
        rootNode.addChild(npmNode);
    }
    return Arrays2.isEmpty(rootNode.getChildren()) ? new Node[0] : new Node[] { rootNode };
}

Example 4 with ExternalProject

use of org.eclipse.n4js.utils.resources.ExternalProject in project n4js by eclipse.

the class ExternalProjectCacheLoader method load.

@Override
public Optional<Pair<N4JSExternalProject, ProjectDescription>> load(final URI rootLocation) throws Exception {
    ProjectDescription projectDescription = packageManager.loadManifestFromProjectRoot(rootLocation);
    if (null != projectDescription) {
        File projectRoot = new File(rootLocation.toFileString());
        ExternalProject p = new ExternalProject(projectRoot, NATURE_ID, BUILDER_ID);
        IN4JSProject pp = new N4JSEclipseProject(p, rootLocation, model);
        N4JSExternalProject ppp = new N4JSExternalProject(projectRoot, pp);
        return Optional.of(Tuples.create(ppp, projectDescription));
    }
    return Optional.absent();
}

Example 5 with ExternalProject

use of org.eclipse.n4js.utils.resources.ExternalProject in project n4js by eclipse.

the class N4MFProjectDependencyStrategy method getProjectDependencies.

@Override
public List<IProject> getProjectDependencies(final IProject project) {
    final IN4JSEclipseProject n4Project = core.create(project).orNull();
    if (null != n4Project) {
        // This covers project dependencies, tests (if any), required REs and required RLs and APIs.
        final Collection<? extends IN4JSEclipseProject> dependencies = n4Project.getDependenciesAndImplementedApis();
        // This is for the provided runtime libraries.
        final Collection<IN4JSEclipseProject> providedRuntimeLibs = from(n4Project.getProvidedRuntimeLibraries()).filter(IN4JSEclipseProject.class).toList();
        // This is for the extended RE, if specified.
        final IN4JSSourceContainerAware srcContainerAware = n4Project.getExtendedRuntimeEnvironment().orNull();
        final IN4JSEclipseProject extendedRE = srcContainerAware instanceof IN4JSEclipseProject ? (IN4JSEclipseProject) srcContainerAware : null;
        int projectCount = dependencies.size() + providedRuntimeLibs.size();
        if (null != extendedRE) {
            projectCount++;
        }
        final IProject[] projects = new IProject[projectCount];
        int i = 0;
        for (final IN4JSEclipseProject dependency : dependencies) {
            projects[i++] = dependency.getProject();
        }
        for (final IN4JSEclipseProject providedRuntimeLib : providedRuntimeLibs) {
            projects[i++] = providedRuntimeLib.getProject();
        }
        if (null != extendedRE) {
            projects[i] = extendedRE.getProject();
        }
        return from(asList(projects)).filter(p -> !(p instanceof ExternalProject)).toList();
    } else {
        return emptyList();
    }
}