Example usage for org.eclipse.jdt.core IJavaProject getPackageFragmentRoots

List of usage examples for org.eclipse.jdt.core IJavaProject getPackageFragmentRoots

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IJavaProject
  6. getPackageFragmentRoots

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaProject getPackageFragmentRoots.

Prototype

IPackageFragmentRoot[] getPackageFragmentRoots() throws JavaModelException;

Source Link

Document

Returns all of the package fragment roots contained in this project, identified on this project's resolved classpath.

Usage

From source file:org.fusesource.ide.branding.wizards.NewCamelTestWizardPageOne.java

License:Open Source License

/**
 * Initialized the page with the current selection
 * //from   w  w  w. j ava2s. co m
 * @param selection
 *            The selection
 */
public void init(IStructuredSelection selection) {
    IJavaElement elem = getInitialJavaElement(selection);
    IJavaProject jproject = elem.getJavaProject();
    IPackageFragmentRoot testRoot = null;

    if (selection != null && !selection.isEmpty()) {
        Object selectedElement = selection.getFirstElement();
        IFile ifile = null;

        if (selectedElement instanceof IFile) {
            ifile = (IFile) selectedElement;
        } else if (selectedElement instanceof IAdaptable) {
            IAdaptable adaptable = (IAdaptable) selectedElement;
            ifile = (IFile) adaptable.getAdapter(IFile.class);
        }

        if (ifile != null) {
            setXmlFileUnderTest(ifile);
        }

        // now we determine the container for the test classes
        if (jproject != null && jproject.exists()) {
            try {
                IPackageFragmentRoot[] roots = jproject.getPackageFragmentRoots();
                for (int i = 0; i < roots.length; i++) {
                    if (roots[i].getKind() == IPackageFragmentRoot.K_SOURCE) {
                        if (roots[i].getPath().toFile().getPath()
                                .contains(String.format("src%stest%sjava", File.separator, File.separator))) {
                            testRoot = roots[i];
                            break;
                        } else if (roots[i].getPath().toFile().getPath()
                                .contains(String.format("src%stest%sscala", File.separator, File.separator))) {
                            testRoot = roots[i];
                            // we will prefer the src/test/java folder, so we don't break here and search for it
                        }
                    }
                }
            } catch (Exception ex) {
                Activator.getLogger().error(ex);
            }
        }
    }

    if (elem != null) {
        initContainerPage(elem);

        // if we found a suitable test class container then we set it here
        if (testRoot != null) {
            // set the container correctly
            setPackageFragmentRoot(testRoot, true);
        }

        IJavaProject project = elem.getJavaProject();
        resourceContainer = project.getProject();

        // evaluate the enclosing type
        IPackageFragment pack = (IPackageFragment) elem.getAncestor(IJavaElement.PACKAGE_FRAGMENT);
        if (pack != null) {
            setPackageFragment(pack, true);
        } else {
            File testFolderFile = project.getProject().getParent().getRawLocation()
                    .append(getPackageFragmentRoot().getPath().makeRelative()).toFile();
            File f = getBasePackage(testFolderFile);
            if (f != null && testRoot != null) {
                IPath p = new Path(f.getPath());
                p = p.makeRelativeTo(project.getProject().getParent().getRawLocation()
                        .append(getPackageFragmentRoot().getPath().makeRelative()));
                String name = "";
                StringTokenizer strTok = new StringTokenizer(p.toOSString(), File.separator);
                while (strTok.hasMoreTokens()) {
                    String tok = strTok.nextToken();
                    if (name.trim().length() > 0) {
                        name += ".";
                    }
                    name += tok;
                }
                try {
                    IPackageFragment pf = testRoot.createPackageFragment(name, true, new NullProgressMonitor());
                    setPackageFragment(pf, true);
                } catch (Exception ex) {
                    Activator.getLogger().error(ex);
                }
            }
        }

        if (fXmlFileUnderTest == null) {
            try {
                // if we have no file selected yet, lets see if there's a
                // single one available
                List<IFile> files = ResourceModelUtils.filter(resourceContainer,
                        new org.fusesource.ide.foundation.core.util.Filter<IFile>() {
                            @Override
                            public boolean matches(IFile file) {
                                if (Objects.equal(file.getFileExtension(), "xml")) {
                                    return camelXmlMatcher.matches(file);
                                }
                                return false;
                            }
                        });
                if (files.size() == 1) {
                    setXmlFileUnderTest(files.get(0));
                }
            } catch (Exception e) {
                Activator.getLogger().error("Failed to search for Camel XML files: " + e, e);
            }
        }
    }
    setJUnit4(true, true);
    updateStatus(getStatusList());
}

From source file:org.fusesource.ide.jvmmonitor.internal.ui.properties.cpu.actions.AddPackageDialog.java

License:Open Source License

/**
 * Gets the package fragments.//from  w  ww.  j a  va  2 s .co  m
 * 
 * @param javaModel
 *            The java model
 * @return The package fragments
 */
private Object[] getPackageFragments(IJavaModel javaModel) {

    Set<String> packageElements = new HashSet<String>();
    IJavaProject[] projects;
    try {
        projects = javaModel.getJavaProjects();
    } catch (JavaModelException e) {
        Activator.log(IStatus.ERROR, Messages.getJavaModelFailedMsg, e);
        return new Object[0];
    }

    for (IJavaProject project : projects) {
        if (EXTERNAL_PLUGIN_LIBRARIES.equals(project.getResource().getName())) {
            continue;
        }

        IPackageFragmentRoot[] packageFragmentRoots;
        try {
            packageFragmentRoots = project.getPackageFragmentRoots();
        } catch (JavaModelException e) {
            continue;
        }

        for (IPackageFragmentRoot packageFragment : packageFragmentRoots) {
            try {
                addPackage(packageElements, packageFragment);
            } catch (JavaModelException e) {
                // do nothing
            }
        }
    }

    for (Object packageName : filteringPackages) {
        packageElements.remove(packageName);
    }

    return packageElements.toArray(new String[0]);
}

From source file:org.grails.ide.eclipse.editor.gsp.translation.GSPTranslation.java

License:Open Source License

/**
 * Originally from ReconcileStepForJava.  Creates an ICompilationUnit from the contents of the JSP document.
 * /*from   ww  w  . j  a  v  a2 s  . co m*/
 * @return an ICompilationUnit from the contents of the JSP document
 */
private ICompilationUnit createCompilationUnit() throws JavaModelException {

    IPackageFragment packageFragment = null;
    IJavaElement je = getJavaProject();

    if (je == null || !je.exists())
        return null;

    switch (je.getElementType()) {
    case IJavaElement.PACKAGE_FRAGMENT:
        je = je.getParent();
        // fall through

    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) je;
        packageFragment = packageFragmentRoot.getPackageFragment(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH);
        break;

    case IJavaElement.JAVA_PROJECT:
        IJavaProject jProject = (IJavaProject) je;

        if (!jProject.exists()) {
            if (DEBUG) {
                System.out.println(
                        "** Abort create working copy: cannot create working copy: JSP is not in a Java project"); //$NON-NLS-1$
            }
            return null;
        }

        packageFragmentRoot = null;
        IPackageFragmentRoot[] packageFragmentRoots = jProject.getPackageFragmentRoots();
        int i = 0;
        while (i < packageFragmentRoots.length) {
            if (!packageFragmentRoots[i].isArchive() && !packageFragmentRoots[i].isExternal()) {
                packageFragmentRoot = packageFragmentRoots[i];
                break;
            }
            i++;
        }
        if (packageFragmentRoot == null) {
            if (DEBUG) {
                System.out.println(
                        "** Abort create working copy: cannot create working copy: JSP is not in a Java project with source package fragment root"); //$NON-NLS-1$
            }
            return null;
        }
        packageFragment = packageFragmentRoot.getPackageFragment(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH);
        break;

    default:
        return null;
    }

    // GRAILS CHANGE
    // create compilation unit with .groovy instead of .java file extension
    ICompilationUnit cu = packageFragment.getCompilationUnit(getClassname() + ".groovy") //$NON-NLS-1$
            .getWorkingCopy(getWorkingCopyOwner(), getProgressMonitor());
    //        ICompilationUnit cu = packageFragment.getCompilationUnit(getClassname() + ".java").getWorkingCopy(getWorkingCopyOwner(), getProgressMonitor()); //$NON-NLS-1$
    setContents(cu);

    // GRAILS CHANGE
    // need extra call to makeConsistent
    // https://issuetracker.springsource.com/browse/STS-3091#comment-79054
    cu.makeConsistent(getProgressMonitor());

    if (DEBUG) {
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"); //$NON-NLS-1$
        System.out.println("(+) JSPTranslation [" + this + "] finished creating CompilationUnit: " + cu); //$NON-NLS-1$ //$NON-NLS-2$
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"); //$NON-NLS-1$
    }

    return cu;
}

From source file:org.grails.ide.eclipse.explorer.providers.GrailsNavigatorContentProvider.java

License:Open Source License

public Object[] getChildren(Object parentElement) {

    if (parentElement instanceof IProject && GrailsNature.isGrailsProject((IProject) parentElement)) {

        IProject project = (IProject) parentElement;

        Collection<GrailsProjectStructureTypes> types = GrailsProjectStructureManager.getInstance()
                .getAllTopLevelLogicalFolders().values();
        List<Object> topLevelFolders = new ArrayList<Object>();

        GrailsFolderElementFactory factory = getFolderElementFactory();
        for (GrailsProjectStructureTypes type : types) {
            ILogicalFolder element = factory.getElement(project,
                    project.getFolder(new Path(type.getFolderName())), type);
            if (element != null) {
                topLevelFolders.add(element);
            }/*ww w  . j av  a  2  s  .com*/
        }

        //Add a logical folder that contains the classpath containers
        topLevelFolders.add(new GrailsClasspathContainersFolder(project));

        // Now add the top level package fragment roots that are
        // non-dependency source folders
        IJavaProject javaProject = JavaCore.create(project);
        try {
            IPackageFragmentRoot[] roots = javaProject.getPackageFragmentRoots();
            if (roots != null) {
                for (IPackageFragmentRoot root : roots) {
                    if (root.getRawClasspathEntry().getEntryKind() == IClasspathEntry.CPE_SOURCE
                            && !GrailsResourceUtil.isGrailsDependencyPackageFragmentRoot(root)) {
                        topLevelFolders.add(root);
                    }
                }
            }
        } catch (JavaModelException e) {
            GrailsCoreActivator.log(e);
        }

        // Add the file folders that are reimaged
        Set<GrailsProjectStructureTypes> fileFolders = GrailsProjectStructureManager.getInstance()
                .getGrailsFileFolders();
        if (fileFolders != null) {
            for (GrailsProjectStructureTypes type : fileFolders) {
                IFolder folder = project.getFolder(new Path(type.getFolderName()));
                if (folder != null && folder.exists()) {
                    topLevelFolders.add(folder);
                }
            }
        }

        try {
            IResource[] children = project.members();
            if (children != null) {
                for (IResource resource : children) {
                    // Skip the linked folders that correspond to
                    // Grails dependency package fragment roots
                    if (!isLinkedDependencyPackageFragmentRoot(resource) && !isReimagedResource(resource)) {
                        topLevelFolders.add(resource);
                    }
                }
            }
        } catch (CoreException e) {
            GrailsCoreActivator.log(e);
        }

        return topLevelFolders.toArray();
    } else if (parentElement instanceof ILogicalFolder) {
        ILogicalFolder element = (ILogicalFolder) parentElement;
        List<?> children = element.getChildren();
        if (children != null) {
            return children.toArray();
        }
    } else if (parentElement instanceof IPackageFragmentRoot) {
        IPackageFragmentRoot root = (IPackageFragmentRoot) parentElement;
        GrailsProjectStructureTypes type = GrailsResourceUtil.getGrailsContainerType(root);
        if (type == GrailsProjectStructureTypes.CONF) {
            try {
                IJavaElement[] children = root.getChildren();
                if (children != null) {
                    List<IJavaElement> elements = new ArrayList<IJavaElement>();
                    for (IJavaElement child : children) {

                        IPackageFragment frag = (child instanceof IPackageFragment) ? (IPackageFragment) child
                                : null;

                        if (frag == null || !frag.isDefaultPackage()) {
                            elements.add(child);
                        } else {
                            IJavaElement[] defaultChildren = frag.getChildren();
                            for (IJavaElement defaultChild : defaultChildren) {
                                elements.add(defaultChild);
                            }
                        }
                    }
                    return elements.toArray();
                }
            } catch (JavaModelException e) {
                GrailsCoreActivator.log(e);
            }
        }
    }
    return null;
}

From source file:org.grails.ide.eclipse.refactoring.util.RefactoringUtils.java

License:Open Source License

/**
 * Creates a default 'search scope' to search for references that need updating in a Grails project. The default scope includes all
 * source folders in the Grails project that actually 'belong' to the project (i.e. all source folders, but excluding 
 * the linked plugin source folders./*  w w  w.j av  a  2 s  . co m*/
 * 
 * @throws JavaModelException 
 */
public static IJavaSearchScope getSearchScope(IJavaProject javaProject) throws JavaModelException {
    IPackageFragmentRoot[] roots = javaProject.getPackageFragmentRoots();
    List<IPackageFragmentRoot> srcFolders = new ArrayList<IPackageFragmentRoot>();
    for (IPackageFragmentRoot root : roots) {
        if (root.getKind() == IPackageFragmentRoot.K_SOURCE) {
            if (!GrailsResourceUtil.isGrailsDependencyPackageFragmentRoot(root)) {
                srcFolders.add(root);
                //               System.out.println(root.getPath());
            }
        }
    }
    return SearchEngine.createJavaSearchScope(srcFolders.toArray(new IJavaElement[srcFolders.size()]));
}

From source file:org.grails.ide.eclipse.ui.contentassist.util.BeansJavaCompletionUtils.java

License:Open Source License

private static IPackageFragment getPackageFragment(IJavaProject project, String prefix)
        throws JavaModelException {
    int dot = prefix.lastIndexOf('.');
    if (dot > -1) {
        String packageName = prefix.substring(0, dot);
        for (IPackageFragmentRoot root : project.getPackageFragmentRoots()) {
            IPackageFragment p = root.getPackageFragment(packageName);
            if (p != null && p.exists()) {
                return p;
            }//from   w ww  . j a  va 2 s . co m
        }
        IPackageFragment[] packages = project.getPackageFragments();
        for (IPackageFragment p : packages) {
            if (p.getElementName().equals(packageName)) {
                return p;
            }
        }
    } else {
        for (IPackageFragmentRoot p : project.getAllPackageFragmentRoots()) {
            if (p.getKind() == IPackageFragmentRoot.K_SOURCE) {
                return p.getPackageFragment("");
            }
        }
    }
    return project.getPackageFragments()[0];
}

From source file:org.gw4e.eclipse.facade.JDTManager.java

License:Open Source License

/**
 * Return a package fragment with the passed path
 * /*from w ww .  ja  v  a  2s  .co m*/
 * @param project
 * @param path
 * @return
 * @throws JavaModelException
 */
public static IPackageFragmentRoot getPackageFragmentRoot(IProject project, IPath path)
        throws JavaModelException {
    IJavaProject javaProject = JavaCore.create(project);
    IPackageFragmentRoot[] roots = javaProject.getPackageFragmentRoots();
    for (int i = 0; i < roots.length; i++) {
        if (roots[i].getPath().equals(path))
            return roots[i];
    }
    return null;
}

From source file:org.gw4e.eclipse.facade.JDTManager.java

License:Open Source License

public static IPackageFragmentRoot findPackageFragmentRoot(IProject project, IPath path)
        throws JavaModelException {
    IJavaProject javaProject = JavaCore.create(project);
    IPackageFragmentRoot[] roots = javaProject.getPackageFragmentRoots();
    for (int i = 0; i < roots.length; i++) {
        if (roots[i].getPath().isPrefixOf(path))
            return roots[i];
    }//from ww w .j a va  2s  .c  om
    return null;
}

From source file:org.gw4e.eclipse.facade.JDTManager.java

License:Open Source License

public static IPath removePackageFragmentRoot(IProject project, IPath path) throws JavaModelException {
    IJavaProject javaProject = JavaCore.create(project);
    IPackageFragmentRoot[] roots = javaProject.getPackageFragmentRoots();
    for (int i = 0; i < roots.length; i++) {
        if (roots[i].getPath().isPrefixOf(path))
            return path.makeRelativeTo(roots[i].getPath());
    }/*  w  w  w . j  av a2  s  .c  o m*/
    return null;
}

From source file:org.gw4e.eclipse.facade.ResourceManager.java

License:Open Source License

/**
 * Return package fragment of the passed resource
 * /*from  w w w  .  ja  v  a 2s. com*/
 * @param project
 * @param path
 * @return
 * @throws JavaModelException
 */
public static IPackageFragmentRoot getPackageFragmentRoot(IProject project, IPackageFragment pkg)
        throws JavaModelException {
    IJavaProject jproject = JavaCore.create(project);
    IPackageFragmentRoot[] roots = jproject.getPackageFragmentRoots();
    for (int i = 0; i < roots.length; i++) {
        IPackageFragmentRoot root = roots[i];
        IPackageFragment pf = root.getPackageFragment(pkg.getElementName());
        if (pf.equals(pkg))
            return root;
    }
    return null;
}