org.hibernate.eclipse.console.test.project.TestProject.java Source code

Java tutorial

Introduction

Here is the source code for org.hibernate.eclipse.console.test.project.TestProject.java

Source

/*******************************************************************************
 * Copyright (c) 2010 Red Hat, Inc.
 * Distributed under license by Red Hat, Inc. All rights reserved.
 * This program is made available under the terms of the
 * Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributor:
 *     Red Hat, Inc. - initial API and implementation
 ******************************************************************************/
package org.hibernate.eclipse.console.test.project;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.osgi.util.NLS;
import org.hibernate.eclipse.console.test.ConsoleTestMessages;
import org.hibernate.eclipse.console.test.HibernateConsoleTestPlugin;
import org.hibernate.eclipse.console.test.project.xpl.JavaProjectHelper;
import org.hibernate.eclipse.console.test.utils.FilesTransfer;

/**
 * Class wraps functionality of eclipse project creation,
 * configuration and deletion.  
 */
public class TestProject {

    public static final String SRC_FOLDER = "src"; //$NON-NLS-1$
    public static final String LIB_FOLDER = "lib"; //$NON-NLS-1$

    public static final Path JRE_CONTAINER = new Path("org.eclipse.jdt.launching.JRE_CONTAINER"); //$NON-NLS-1$

    protected IProject project;
    protected IJavaProject javaProject;

    final protected String projectName;

    public TestProject(String projectName) {
        this.projectName = projectName;
        initialize();
    }

    public void initialize() {
        try {
            buildProject();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    protected void buildProject() throws JavaModelException, CoreException, IOException {
        project = buildNewProject(projectName);
        javaProject = buildJavaProject(project);
    }

    public IProject getIProject() {
        return project;
    }

    public IJavaProject getIJavaProject() {
        return javaProject;
    }

    public void deleteIProject() {
        deleteIProject(true);
    }

    public void deleteIProject(boolean deleteContent) {
        Exception ex = null;
        final int maxTryNum = 20;
        for (int i = 0; i < maxTryNum; i++) {
            ex = null;
            try {
                IContainer container = project.getParent();
                project.delete(deleteContent, true, null);
                container.refreshLocal(IResource.DEPTH_ONE, null);
                i = maxTryNum;
            } catch (CoreException e) {
                ex = e;
                if (i + 1 < maxTryNum) {
                    try {
                        Thread.sleep((i + 1) * 500);
                    } catch (InterruptedException e1) {
                    }
                }
            }
        }
        if (ex != null) {
            throw new RuntimeException(ex);
        }
        javaProject = null;
        project = null;
    }

    public void addJavaNature() throws CoreException {
        if (!project.hasNature(JavaCore.NATURE_ID)) {
            JavaProjectHelper.addNatureToProject(project, JavaCore.NATURE_ID, null);
        }
    }

    protected IJavaProject buildJavaProject(IProject project) {
        IJavaProject javaProject = JavaCore.create(project);
        try {
            addJavaNature();
        } catch (CoreException ce) {
            throw new RuntimeException(ce);
        }
        javaProject.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
        javaProject.setOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_5);
        javaProject.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5);
        return javaProject;
    }

    public IProject buildNewProject(String projectName) {
        // get a project handle
        final IProject newProjectHandle = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
        // get a project descriptor
        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        final IProjectDescription description = workspace.newProjectDescription(newProjectHandle.getName());
        try {
            createAndOpenProject(description, newProjectHandle);
        } catch (CoreException ce) {
            throw new RuntimeException(ce);
        }
        return newProjectHandle;
    }

    protected void createAndOpenProject(IProjectDescription description, IProject projectHandle)
            throws CoreException {
        projectHandle.create(description, null);
        projectHandle.open(IResource.BACKGROUND_REFRESH, null);
    }

    public IPackageFragmentRoot createFolder(String strFolder) throws CoreException {
        IPath path = Path.fromOSString(strFolder);
        for (int i = 0; i < path.segmentCount(); i++) {
            IFolder folder = project.getFolder(path.uptoSegment(i + 1).toOSString());
            if (!folder.exists()) {
                folder.create(true, true, null);
            }
        }
        IFolder folder = project.getFolder(strFolder);
        if (!folder.exists()) {
            folder.create(true, true, null);
        }
        return javaProject.getPackageFragmentRoot(folder);
    }

    public IPackageFragmentRoot createSourceFolder() throws CoreException {
        return createFolder(SRC_FOLDER);
    }

    public List<IPath> copyLibs(File res) throws CoreException {
        return copyLibs2(res.getAbsolutePath());
    }

    public List<IPath> copyLibs2(String absolutePath) throws CoreException {
        IFolder dst = project.getFolder(LIB_FOLDER);
        if (!dst.exists()) {
            dst.create(true, true, null);
            javaProject.getPackageFragmentRoot(dst);
        }
        File libFolder = new File(absolutePath);
        if (!libFolder.exists()) {
            String out = NLS.bind(ConsoleTestMessages.MappingTestProject_folder_not_found, absolutePath);
            throw new RuntimeException(out);
        }
        List<IPath> libs = new ArrayList<IPath>();
        FilesTransfer.copyFolder(libFolder, dst, FilesTransfer.filterFilesJar, FilesTransfer.filterFolders, libs);
        return libs;
    }

    public void generateClassPath(List<IPath> libs, IPackageFragmentRoot sourceFolder) throws JavaModelException {
        List<IClasspathEntry> entries = new ArrayList<IClasspathEntry>();
        //entries.addAll(Arrays.asList(javaProject.getRawClasspath()));
        for (IPath lib_path : libs) {
            entries.add(JavaCore.newLibraryEntry(lib_path, null, null));
        }
        if (sourceFolder != null) {
            entries.add(JavaCore.newSourceEntry(sourceFolder.getPath()));
        }
        entries.add(JavaCore.newContainerEntry(JRE_CONTAINER));
        javaProject.setRawClasspath(entries.toArray(new IClasspathEntry[0]), null);
    }

    static public File getFolder(String path) throws IOException {
        URL entry = HibernateConsoleTestPlugin.getDefault().getBundle().getEntry(path);
        URL resProject = FileLocator.resolve(entry);
        String resolvePath = FileLocator.resolve(resProject).getFile();
        File folder = new File(resolvePath);
        if (!folder.exists()) {
            String out = NLS.bind(ConsoleTestMessages.MappingTestProject_folder_not_found, path);
            throw new RuntimeException(out);
        }
        return folder;
    }

    @SuppressWarnings("unused")
    public void fullBuild() throws CoreException {
        IPackageFragmentRoot sourcePackageFragment = createSourceFolder();
        project.refreshLocal(IResource.DEPTH_INFINITE, null);
        ////sourcePackageFragment.getResource().refreshLocal();
        //project.build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
        //project.refreshLocal(IResource.DEPTH_INFINITE, null);
        project.build(IncrementalProjectBuilder.FULL_BUILD, new NullProgressMonitor());
        project.refreshLocal(IResource.DEPTH_INFINITE, null);
        project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, new NullProgressMonitor());
        project.refreshLocal(IResource.DEPTH_INFINITE, null);
    }
}