Examples with IN4JSProject org.eclipse.n4js.projectModel.IN4JSProject used on opensource projects

Example 41 with IN4JSProject

use of org.eclipse.n4js.projectModel.IN4JSProject in project n4js by eclipse.

the class ExternalLibraryBuilder method ensureDynamicDependenciesSetForWorkspaceProjects.

/**
 * Make sure the project description is available and cached for each workspace projects. This is important to avoid
 * performing a workspace operation (with no scheduling rule) when setting the dynamic project references for each
 * project.
 *
 * See: ProjectDescriptionLoadListener#updateProjectReferencesIfNecessary(IProject)
 */
private void ensureDynamicDependenciesSetForWorkspaceProjects() {
    for (IProject project : getWorkspace().getRoot().getProjects()) {
        org.eclipse.emf.common.util.URI uri = createPlatformResourceURI(project.getName(), true);
        IN4JSProject n4Project = core.findProject(uri).get();
        if (null != n4Project) {
            // This will trigger dynamic project reference update.
            n4Project.getProjectId();
        }
    }
}

Example 42 with IN4JSProject

use of org.eclipse.n4js.projectModel.IN4JSProject in project n4js by eclipse.

the class ExternalLibraryBuilder method doPerformOperation.

private List<IProject> doPerformOperation(N4JSExternalProject[] projects, BuildOperation operation, IProgressMonitor monitor) {
    if (projects == null || projects.length == 0) {
        return Collections.emptyList();
    }
    ISchedulingRule rule = getRule();
    try {
        Job.getJobManager().beginRule(rule, monitor);
        VertexOrder<IN4JSProject> buildOrder = builtOrderComputer.getBuildOrder(projects);
        // wrap as Arrays.asList returns immutable list
        List<IN4JSProject> buildOrderList = new ArrayList<>(Arrays.asList(buildOrder.vertexes));
        if (BuildOperation.CLEAN.equals(operation)) {
            Collections.reverse(buildOrderList);
        }
        // Remove external projects that have the workspace counterpart if it is a build operation.
        if (BuildOperation.BUILD.equals(operation)) {
            for (Iterator<IN4JSProject> itr = buildOrderList.iterator(); itr.hasNext(); ) {
                if (hasWorkspaceCounterpart(itr.next())) {
                    itr.remove();
                }
            }
        }
        ensureDynamicDependenciesSetForWorkspaceProjects();
        String prefix = Strings.toFirstUpper(operation.toString().toLowerCase());
        String projectNames = getProjectNames(buildOrderList);
        LOGGER.info(prefix + "ing external libraries: " + projectNames);
        SubMonitor subMonitor = SubMonitor.convert(monitor, buildOrderList.size());
        List<IProject> actualBuildOrderList = new LinkedList<>();
        for (IN4JSProject project : buildOrderList) {
            LOGGER.info(prefix + "ing external library: " + project.getProjectId());
            // bold cast
            N4JSEclipseProject n4EclPrj = (N4JSEclipseProject) project;
            operation.run(this, n4EclPrj, subMonitor.newChild(1));
            IProject iProject = n4EclPrj.getProject();
            actualBuildOrderList.add(iProject);
        }
        return actualBuildOrderList;
    } finally {
        Job.getJobManager().endRule(rule);
    }
}

Example 43 with IN4JSProject

use of org.eclipse.n4js.projectModel.IN4JSProject 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 44 with IN4JSProject

use of org.eclipse.n4js.projectModel.IN4JSProject 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 45 with IN4JSProject

use of org.eclipse.n4js.projectModel.IN4JSProject 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();
}