com.microsoft.javapkgbuild.Tasks.java Source code

Introduction

Here is the source code for com.microsoft.javapkgbuild.Tasks.java

Source

// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT License.  See LICENSE file in the project root for license information.

package com.microsoft.javapkgbuild;

import java.io.FileOutputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class Tasks {

    public static void logo() {
        System.out.println("Java Package Build tool");
        System.out.println();
    }

    public static void runHelp() {
        System.out.println("Supported tasks:");
        System.out.println("\t-help: displays this help string");
        System.out.println("\t-displayProjects: lists all projects from the loaded workspace");
        System.out.println("\t-displayReferences projectName : lists classpath for the specified project");
        System.out.println(
                "\t-exportReferences projectName outputFileName : stores classpath of the specified project in an xml output file");
    }

    public static void runTaskNotRecognised(String task) {
        System.err.println("Error: Task not supported: " + task);
        runHelp();
    }

    public static void invalidParameters(String task) {
        System.err.println("Error: Invalid parameters specified for task: " + task);
        runHelp();
    }

    public static void displayReferences(String projectName) throws JavaModelException {
        IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
        IProject project = workspaceRoot.getProject(projectName);
        IJavaProject javaProject = JavaCore.create(project);

        IClasspathEntry[] classPathList = javaProject.getResolvedClasspath(true);
        for (IClasspathEntry cp : classPathList) {
            System.out.println(cp.toString());
        }
    }

    public static void displayProjects() {
        IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
        IProject[] projects = workspaceRoot.getProjects(0);
        for (IProject proj : projects) {
            System.out.println(proj.getName() + " - " + proj.getLocationURI().toString());
        }
    }

    public static void exportReferences(String projectName, String outputFileName) throws JavaModelException {
        try {
            IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
            IProject project = workspaceRoot.getProject(projectName);
            IJavaProject javaProject = JavaCore.create(project);

            DocumentBuilderFactory xFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = xFactory.newDocumentBuilder();
            Document doc = builder.newDocument();

            Element mainRoot = doc.createElement("classpath");
            mainRoot.setAttribute("projectName", projectName);
            doc.appendChild(mainRoot);

            IClasspathEntry[] classPathList = javaProject.getResolvedClasspath(true);
            for (IClasspathEntry cp : classPathList) {
                Element cpNode = doc.createElement("classpathentry");
                cpNode.setAttribute("path", cp.getPath().toOSString());
                cpNode.setAttribute("kind", getClassPathType(cp));
                cpNode.setAttribute("exported", Boolean.toString(cp.isExported()));

                IPath sourceFolder = cp.getSourceAttachmentPath();
                if (cp.getEntryKind() == IClasspathEntry.CPE_LIBRARY && sourceFolder != null)
                    cpNode.setAttribute("sourcepath", sourceFolder.toOSString());

                mainRoot.appendChild(cpNode);
            }

            Transformer transformer = TransformerFactory.newInstance().newTransformer();
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            DOMSource source = new DOMSource(doc);

            FileOutputStream fos = new FileOutputStream(outputFileName);
            StreamResult outFile = new StreamResult(fos);
            transformer.transform(source, outFile);
            fos.close();

            System.out.println("Output file is: " + outputFileName);
        } catch (Exception e) {
            e.printStackTrace(System.err);
        }
    }

    private static String getClassPathType(IClasspathEntry cp) {
        switch (cp.getEntryKind()) {
        case IClasspathEntry.CPE_CONTAINER:
            return "con";
        case IClasspathEntry.CPE_LIBRARY:
            return "lib";
        case IClasspathEntry.CPE_PROJECT:
            return "proj";
        case IClasspathEntry.CPE_SOURCE:
            return "src";
        case IClasspathEntry.CPE_VARIABLE:
            return "var";
        default:
            return "unexpected";
        }
    }
}