Building Eclipse Plugins with Maven 2

protected void doExecute()
        throws MojoExecutionException, MojoFailureException {
    if (!eclipseHome.isDirectory()) {
        throw new MojoExecutionException(
            "The 'eclipseHome' location '" +
             eclipseHome +
              "' is not a valid directory");
    }
    if (repositoryHome == null) {
        repositoryHome = new File(
            System.getProperty(KEY_USER_DIR));
        getLog().info("Defaulting 'repositoryHome' to '" +
            repositoryHome + "'");
    }
    if (!repositoryHome.isDirectory()) {
        throw new MojoExecutionException(
            "The 'repositoryHome' location '" +
            repositoryHome +
            "' is not a valid directory");
    }
    if (prefix == null) {
        getLog().info("Defaulting 'prefix' to '<none>'");
    }
    if (prefix != null) {
        String[] temp = prefix.split(",");
        for (int i = 0; i < temp.length; i++) {
            String prefix = temp[i];
            if (!prefix.endsWith(".")) {
                prefix = prefix + ".";
            }
            prefixes.add(prefix);
        }
    }
    try {
        populateRepository();
    } catch (IOException e) {
        throw new MojoExecutionException(
            "Repository population failed", e);
    }
    try {
        writePOMs();
    } catch (IOException e) {
        throw new MojoExecutionException(
            "POM writing failed", e);
    }
    try {
        createPOMDeploymentScript();
    } catch (IOException e) {
        throw new MojoExecutionException(
            "POM deployment script creation failed", e);
    }
}
                            

protected void doExecute()
        throws MojoExecutionException, MojoFailureException {
    if (logModifications) {
        logOriginalPom();
    }
    if ((manifest == null) || !manifest.exists()) {
        String path = baseDirectory.getAbsolutePath() +
            File.separator +
            ManifestConstants.MANIFEST_DIRECTORY +
            File.separator +
            ManifestConstants.MANIFEST_FILE_NAME;
        manifest = new File(path);
    }
    if (manifest.exists()) {
        try {
            FileInputStream fileInputStream =
                new FileInputStream(manifest);
            Manifest manifest = new Manifest(fileInputStream);
            ManifestParser parser = new ManifestParser(manifest);
            parser.setGroupId(mavenProject.getGroupId());
            parser.parse();
            DependencyManagement parsedManagement =
                parser.getDependencyManagement();
            List dependencies = parsedManagement.getDependencies();
            if (dependencies != null && dependencies.size() > 0) {
                Iterator iterator = dependencies.iterator();
                while (iterator.hasNext()) {
                    Dependency dependency =
                        (Dependency) iterator.next();
                    if (dependency.getVersion() == null) {
                        dependency.setVersion(parser.getVersion());
                    }
                    convertToSnapshotVersion(dependency);
                    if (ManifestConstants.SCOPE_SYSTEM.equals(
                        dependency.getScope())) {
                        String systemPath =
                            dependency.getSystemPath();
                        File file = new File(systemPath);
                        if (!file.exists()) {
                            file = new File(baseDirectory,
                                systemPath);
                            dependency.setSystemPath(
                                file.getAbsolutePath());
                        }
                    } else {
                        String type =
                            mavenProject.getProperties().
                                getProperty(
                                    dependency.getArtifactId());
                        if (type != null) {
                            dependency.setType(type);
                        } else {
                            Artifact artifact =
                                artifactFactory.createBuildArtifact(
                                    dependency.getGroupId(),
                                    dependency.getArtifactId(),
                                    dependency.getVersion(),
                                    "jar");
                            try {
                                artifactResolver.resolve(
                                    artifact,
                                    mavenProject.
                                        getRemoteArtifactRepositories(),
                                    artifactRepository);
                                dependency.setType("jar");
                            } catch (Exception e) {
                                // Do Nothing
                                // since the default is 'pom'
                            }
                        }
                    }
                    mavenProject.getDependencies().add(dependency);
                }
            }
        } catch (IOException e) {
            throw new MojoExecutionException(
                "Failed to update POM from Eclipse Manifest", e);
        }
    } else if (requireManifest) {
        throw new MojoExecutionException(
            "The Manifest file cannot be found.");
    }
    if (logModifications) {
        logModifiedPom();
    }
}
                            

protected void doExecute()
        throws MojoExecutionException, MojoFailureException {
    String packaging = project.getPackaging();
    if ((packaging.equals("pom")) ||
        (packaging.equals("binary-plugin"))) {
        getLog().debug(
            "Nothing to do for packaging '" +
            packaging +
            "'");
        return;
    }
    File jarFile = createArchive();
    String classifier = getClassifier();
    if (classifier != null) {
        projectHelper.attachArtifact(
            getProject(),
            "jar",
            classifier,
            jarFile);
    } else {
        getProject().getArtifact().setFile(jarFile);
    }
}
                            

protected void doExecute()
        throws MojoExecutionException, MojoFailureException {
    File manifestDirectory = new File(
        destinationDirectory,
        MANIFEST_DIRECTORY);
    getLog().debug("The manifestDir is " + manifestDirectory);
    if (!manifestDirectory.exists()) {
        if (!manifestDirectory.mkdir()) {
            throw new MojoExecutionException(
            "Unable to create directory '" +
            manifestDirectory +
            "'");
        }
    }
    libDirectory = new File(destinationDirectory, LIB_DIRECTORY);
    getLog().debug("The libDir is " + libDirectory);
    if (!libDirectory.exists()) {
        if (!libDirectory.mkdir()) {
            throw new MojoExecutionException(
                "Unable to create directory '" +
                libDirectory +
                "'");
        }
    }
    File manifestFile = getManifestFile(manifestDirectory);
    Manifest manifest = new Manifest();
    Attributes mainAttributes = manifest.getMainAttributes();
    writeInitialManifestAttributes(mainAttributes);
    resolveBundleClasspathEntries(mainAttributes);
    writeManifestToFile(manifestFile, manifest);
}
                            

protected void doExecute()
        throws MojoExecutionException, MojoFailureException {
    if (!needsToRunTests()) {
        return;
    }
    setupDefaults();
    PDETestEclipseValidator validator =
        new PDETestEclipseValidator(getLog(),
            baseDirectory,
            eclipseDirectory,
            prefixes,
            testFrameworkVersion);
    validator.execute();
    File targetDirectory = new File(baseDirectory,
        PDETestConstants.TARGET_DIRECTORY);
    File testDirectory = new File(targetDirectory,
        PDETestConstants.PDE_TEST_DIRECTORY);
    if (!testDirectory.exists()) {
        if (!testDirectory.mkdirs()) {
            throw new MojoExecutionException(
                "Unable to create '" +
                PDETestConstants.PDE_TEST_DIRECTORY +
                "' directory '" +
                testDirectory +
                "'");
        }
    }
    PDETestEclipseCleaner cleaner = new PDETestEclipseCleaner(
        getLog(),
        baseDirectory,
        eclipseDirectory,
        prefixes);
    cleaner.execute();
    File buildFile = new File(testDirectory, "test.xml");
    PDETestFileBuilder builder = new PDETestFileBuilder(
        getLog(),
        baseDirectory,
        eclipseDirectory,
        prefixes,
        project,
        buildFile,
        testOutputDirectory,
        project.getArtifactId(),
        testFrameworkVersion);
    builder.execute();
    PDETestDeployer deployer = new PDETestDeployer(
        getLog(),
        baseDirectory,
        eclipseDirectory,
        prefixes,
        project,
        session);
    deployer.execute();
    PDETestRunner runner = new PDETestRunner(
        getLog(),
        baseDirectory,
        eclipseDirectory,
        prefixes
        buildFile,
        testFailureIgnore);
    runner.execute();
}
                            

protected void doExecute()
        throws MojoExecutionException, MojoFailureException {
    File eclipseDirectory = getEclipseDirectory();
    getLog().info(
        "Validating target Eclipse environment in '" +
        eclipseDirectory +
        "'...");
    if (!eclipseDirectory.isDirectory()) {
        throw new MojoExecutionException(
        "The Eclipse directory location '" +
        eclipseDirectory +
        "' is not a valid directory");
    }
    File startupJarFile = getStartupJarFile();
    getLog().debug(
        "Eclipse startup jar must be in '" +
        startupJarFile +
        ".");
    if (!startupJarFile.exists()) {
        getLog().debug(
            "The file '" +
            startupJarFile +
            "' does not exist.");
        throw new MojoExecutionException(
        "The required startup jar file was not found in '" +
        eclipseDirectory +
        "'");
    }
    File pluginsDirectory = getPluginsDirectory();
    getLog().debug(
        "Eclipse plugins directory must be in '" +
        pluginsDirectory +
        ".");
    if (!pluginsDirectory.isDirectory()) {
        getLog().debug(
        "The location '" +
        pluginsDirectory +
        "' does not exist or is not a directory.");
        throw new MojoExecutionException(
            "The required plugins directory was not found in '" +
            eclipseDirectory +
            "'");
    }
    getLog().debug(
        "The Eclipse PDE test framework version is '" +
        testFrameworkVersion +
        "'.");
    File testPluginDirectory = new File(
        pluginsDirectory,
        "org.eclipse.test_" +
        testFrameworkVersion);
    getLog().debug(
        "The Eclipse PDE test framework plugin must be in '" +
        testPluginDirectory +
        "'.");
    if (!testPluginDirectory.isDirectory()) {
        getLog().debug(
            "The Eclipse PDE test framework plugin does not exist.");
        throw new MojoExecutionException(
            "The required Eclipse test framework plugin '" +
            "org.eclipse.test_" +
            testFrameworkVersion +
            "' was not found in '" +
            pluginsDirectory +
            "'");
    }
}
                            

protected void doExecute()
        throws MojoExecutionException, MojoFailureException {
    File eclipseDirectory = getEclipseDirectory();
    getLog().info(
        "Cleaning target Eclipse environment in '" +
        eclipseDirectory +
        "'...");
    File pluginsDirectory = getPluginsDirectory();
    getLog().debug(
        "Looking for plugins in '" +
        pluginsDirectory +
        "'...");
    File[] files = pluginsDirectory.listFiles();
    for (int i = 0; i < files.length; i++) {
        String name = files[i].getName();
        if (!isMatchForPrefix(name)) {
            getLog().debug("Skipping plugin '" + name + "'.");
            continue;
        }
        getLog().info("Cleaning plug-in '" + name + "'...");
        if (files[i].isDirectory()) {
            deleteDirectory(files[i]);
        } else {
            deleteFile(files[i]);
        }
    }
}
                            

protected void doExecute()
        throws MojoExecutionException, MojoFailureException {
    getLog().info(
        "Building 'test.xml' for PDE testing in '" +
        file +
        "'...");
    findCoberturaJar();
    buffer.append("<?xml version=\"1.0\"?>\n\n");
    buffer.append("<!-- Auto-generated file - DO NOT MODIFY! -->\n\n");
    buffer.append("<project name=\"");
    getLog().debug("The artifact id is '" + artifactId + "'.");
    buffer.append(artifactId);
    buffer.append("\" default=\"run\" basedir=\"");
    buffer.append(getBaseDirectory().getAbsolutePath());
    buffer.append("\">\n");
    appendProperties();
    appendInitTarget();
    List testClasses = new ArrayList();
    findTestClasses(directory, testClasses);
    appendSuiteTarget(testClasses);
    appendCleanupTarget();
    appendRunTarget();
    buffer.append("</project>\n");
    try {
        FileWriter writer = new FileWriter(file);
        writer.write(buffer.toString());
        writer.close();
    } catch (IOException e) {
        throw new MojoExecutionException(
            "Unable to create 'test.xml'", e);
    }
}
                            

protected void doExecute()
        throws MojoExecutionException, MojoFailureException {
    getLog().info(
        "Deploying test artifacts and dependencies to target " + 
        "Eclipse environment in '" +
        getEclipseDirectory() +
        "'...");
    deployPluginArtifact();
    deployDependencies();
}

/**
 * Deploys the plugin artifact itself.
 * @throws MojoExecutionException
 */
private void deployPluginArtifact() throws MojoExecutionException {
    getLog().debug("Deploying the plugin artifact...");
    File targetDirectory = new File(
        getBaseDirectory(),
        PDETestConstants.TARGET_DIRECTORY);
    File testDirectory = new File(
        targetDirectory,
        PDETestConstants.PDE_TEST_DIRECTORY);
    String artifactName =
        project.getArtifactId() + "-" +
        project.getVersion() +
        DeployConstants.EXTENSION_JAR;
    File sourceFile = new File(testDirectory, artifactName);
    File pluginsDirectory = getPluginsDirectory();
    File destinationFile = new File(pluginsDirectory, artifactName);
    try {
        copyFile(sourceFile, destinationFile);
    } catch (IOException e) {
        throw new MojoExecutionException(
        "Unable to deploy plugin artifact", e);
    }
}
                            

/**
 * Deploys the plugin artifact's dependencies.
 * @throws MojoExecutionException 
 * @throws MojoFailureException 
 */
private void deployDependencies()
        throws MojoExecutionException, MojoFailureException {
    getLog().debug("Deploying the dependent artifacts...");
    Iterator artifacts = project.getDependencyArtifacts().iterator();
    while (artifacts.hasNext()) {
        Artifact artifact = (Artifact) artifacts.next();
        getLog().debug("Processing artifact: " + artifact);
        String scope = artifact.getScope();
        if (!Artifact.SCOPE_COMPILE.equals(scope)) {
            getLog().debug(
                "Skipping artifact with '" +
                scope +
                "' scope.");
            continue;
        }
        if (isMatchForPrefix(artifact.getArtifactId())) {
            String type = artifact.getType();
            if (DeployConstants.PACKAGING_JAR.equals(type)) {
                deployJar(artifact);
            } else if (DeployConstants.PACKAGING_POM.equals(type)) {
                deployPom(artifact);
            } else {
                getLog().warn(
                    "Don't know how to deploy artifact with type '" +
                    type +
                    "'.");
            }
        }
    }
}
                            

protected void doExecute()
        throws MojoExecutionException, MojoFailureException {
    String command = createCommand();
    ProgramRunner runner = new ProgramRunner(command);
    try {
        runner.execute();
    } catch (IOException e) {
        throw new MojoExecutionException(
            "The Eclipse launch failed", e);
    } catch (InterruptedException e) {
        throw new MojoExecutionException(
            "The Eclipse execution was interrupted", e);
    }
    extractErrorsAndFailures();
}
                            

/**
 * Extracts errors and failures from the surefire reports.
 * @throws MojoExecutionException
 * @throws MojoFailureException
 */
private void extractErrorsAndFailures()
        throws MojoExecutionException, MojoFailureException {
    getLog().info(
        "Extracting errors and failures from surefire reports");
    System.out.println(
        "-------------------------------------------------------");
    System.out.println(" T E S T S ");
    System.out.println(
        "-------------------------------------------------------");
    File targetDirectory = new File(
        getBaseDirectory(),
        PDETestConstants.TARGET_DIRECTORY);
    File surefireDirectory = new File(
        targetDirectory,
        PDETestConstants.SUREFIRE_DIRECTORY);
    if (!surefireDirectory.isDirectory()) {
        getLog().warn(
            "The surefire reports directory '" +
            surefireDirectory +
            "' was not created.");
        return;
    }
    File[] files = surefireDirectory.listFiles();
    if ((files == null) || (files.length == 0)) {
        getLog().warn("No surefire reports were moved.");
        return;
    }
    try {
        DocumentBuilderFactory factory =
            DocumentBuilderFactory.newInstance();
        builder = factory.newDocumentBuilder();
    } catch (Exception e) {
        throw new MojoExecutionException(
            "Unable to create XML document builder", e);
    }
    for (int i = 0; i < files.length; i++) {
        String name = files[i].getName();
        if (name.endsWith(".xml")) {
            extractErrorsAndFailures(files[i]);
        }
    }
    if ((failures > 0) || (errors > 0)) {
        if (testFailureIgnore) {
            getLog().info("Ignoring test failures");
            return;
        }
        StringBuffer buffer = new StringBuffer();
        buffer.append("There are test ");
        if (failures > 0) {
            buffer.append("failures");
            if (errors > 0) {
                buffer.append(" and ");
            }
        }
        if (errors > 0) {
            buffer.append("errors");
        }
        buffer.append(".");
        throw new MojoFailureException(buffer.toString());
    }
}
                            

<component>
    <role>
        org.apache.maven.lifecycle.mapping.LifecycleMapping
    </role>
    <role-hint>source-plugin</role-hint>
    <implementation>
        org.apache.maven.lifecycle.mapping.DefaultLifecycleMapping
    </implementation>
    <configuration>
        <lifecycles>
            <lifecycle>
                <id>default</id>
                <phases>
                    <process-resources>
                        org.apache.maven.plugins:maven-resources-plugin:resources
                    </process-resources>
                    <compile>
                        org.apache.maven.plugins:maven-compiler-plugin:compile
                    </compile>
                    <process-test-resources>
                        org.apache.maven.plugins:maven-resources-plugin:testResources
                    </process-test-resources>
                    <test-compile>
                        org.apache.maven.plugins:maven-compiler-plugin:testCompile
                    </test-compile>
                    <test>
                        org.apache.maven.plugins:maven-psteclipse-plugin:test
                    </test>
                    <package>
                        org.apache.maven.plugins:maven-psteclipse-plugin:package
                    </package>
                    <install>
                        org.apache.maven.plugins:maven-install-plugin:install
                    </install>
                    <deploy>
                        org.apache.maven.plugins:maven-deploy-plugin:deploy
                    </deploy>
                </phases>
            </lifecycle>
        </lifecycles>
    </configuration>
</component>
                                

<component>
    <role>
        org.apache.maven.lifecycle.mapping.LifecycleMapping
    </role>
    <role-hint>binary-plugin</role-hint>
    <implementation>
        org.apache.maven.lifecycle.mapping.DefaultLifecycleMapping
    </implementation>
    <configuration>
        <lifecycles>
            <lifecycle>
                <id>default</id>
                <phases>
                    <package>
                        org.apache.maven.plugins:maven-site-plugin:attach-descriptor
                    </package>
                    <install>
                        org.apache.maven.plugins:maven-psteclipse-plugin:install
                    </install>
                    <deploy>
                        org.apache.maven.plugins:maven-deploy-plugin:deploy
                    </deploy>
                </phases>
                <optional-mojos>
                    <optional-mojo>
                        org.apache.maven.plugins:maven-site-plugin:attach-descriptor
                    </optional-mojo>
                </optional-mojos>
            </lifecycle>
        </lifecycles>
    </configuration>
</component>

<component>
    <role>
        org.apache.maven.artifact.handler.ArtifactHandler
    </role>
    <role-hint>source-plugin</role-hint>
    <implementation>
        org.apache.maven.artifact.handler.DefaultArtifactHandler
    </implementation>
    <configuration>
        <extension>jar</extension>
        <type>source-plugin</type>
        <packaging>source-plugin</packaging>
        <language>java</language>
        <addedToClasspath>true</addedToClasspath>
    </configuration>
</component>

<component>
    <role>
        org.apache.maven.artifact.handler.ArtifactHandler
    </role>
    <role-hint>binary-plugin</role-hint>
    <implementation>
        org.apache.maven.artifact.handler.DefaultArtifactHandler
    </implementation>
    <configuration>
        <extension>pom</extension>
        <type>binary-plugin</type>
        <packaging>binary-plugin</packaging>
        <language>java</language>
        <addedToClasspath>true</addedToClasspath>
    </configuration>
</component>