<change id="GeneratorUtilities-createFromTemplate">

             <api name="general"/>

             <summary>Added <code>GeneratorUtilities.createFromTemplate</code>.</summary>

             <version major="0" minor="100"/>

             <date day="27" month="3" year="2012"/>

             <author login="ralphbenjamin"/>

             <compatibility addition="yes" binary="compatible" semantic="compatible" source="compatible" deletion="no" deprecation="no" modification="no"/>

             <description>

                 Added the method <code>createFromTemplate</code> to class <code>GeneratorUtilities</code>,

                 which will create a new CompilationUnitTree from a template.

             </description>

             <class package="org.netbeans.api.java.source" name="GeneratorUtilities"/>

             <issue number="209798"/>

        </change>

import java.net.URI;

import javax.tools.JavaFileObject;

import org.netbeans.modules.java.source.parsing.FileObjects;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

     * Create a new CompilationUnitTree from a template.

     *

     * @param sourceRoot a source root under which the new file is created

     * @param path a relative path to file separated by '/'

     * @param kind the kind of Element to use for the template, can be null or

     * CLASS, INTERFACE, ANNOTATION_TYPE, ENUM, PACKAGE

     * @return new CompilationUnitTree created from a template

     * @throws IOException when an exception occurs while creating the template

     * @since 0.100

     */

    public CompilationUnitTree createFromTemplate(FileObject sourceRoot, String path, ElementKind kind) throws IOException {

        String[] nameComponent = FileObjects.getFolderAndBaseName(path, '/');

        JavaFileObject sourceFile = FileObjects.templateFileObject(sourceRoot, nameComponent[0], nameComponent[1]);

        FileObject template = FileUtil.getConfigFile(copy.template(kind));

        FileObject targetFile = copy.doCreateFromTemplate(template, sourceFile);

        CompilationUnitTree templateCUT = copy.impl.getJavacTask().parse(FileObjects.nbFileObject(targetFile, targetFile.getParent())).iterator().next();

        CompilationUnitTree importComments = GeneratorUtilities.get(copy).importComments(templateCUT, templateCUT);

        CompilationUnitTree result = copy.getTreeMaker().CompilationUnit(importComments.getPackageAnnotations(),

                sourceRoot,

                path,

                importComments.getImports(),

                importComments.getTypeDecls());

        return result;

    }

    /**

import java.net.URI;

import javax.lang.model.element.ElementKind;

                CompilationUnitTree importComments = GeneratorUtilities.get(this).importComments(templateCUT, templateCUT);

            case PACKAGE: return "Templates/Classes/package-info.java"; // NOI18N

import javax.lang.model.element.ElementKind;

    public void testNewCompilationUnitFromTemplate() throws Exception {

        testFile = new File(getWorkDir(), "Test.java");

        File fakeFile = new File(getWorkDir(), "Fake.java");

        FileObject fakeFO = FileUtil.createData(fakeFile);

        FileObject emptyJava = FileUtil.createData(FileUtil.getConfigRoot(), "Templates/Classes/Empty.java");

        emptyJava.setAttribute("template", Boolean.TRUE);

        FileObject classJava = FileUtil.createData(FileUtil.getConfigRoot(), "Templates/Classes/Class.java");

        classJava.setAttribute("template", Boolean.TRUE);

        Writer w = new OutputStreamWriter(classJava.getOutputStream(), "UTF-8");

        w.write("package zoo;\n"

                + "/**\n * trida\n */\n"

                + "public class Template {\n"

                + "}");

        w.close();

        FileObject testSourceFO = FileUtil.createData(testFile); assertNotNull(testSourceFO);

        ClassPath sourcePath = ClassPath.getClassPath(testSourceFO, ClassPath.SOURCE); assertNotNull(sourcePath);

        FileObject[] roots = sourcePath.getRoots(); assertEquals(1, roots.length);

        final FileObject sourceRoot = roots[0]; assertNotNull(sourceRoot);

        ClassPath compilePath = ClassPath.getClassPath(testSourceFO, ClassPath.COMPILE); assertNotNull(compilePath);

        ClassPath bootPath = ClassPath.getClassPath(testSourceFO, ClassPath.BOOT); assertNotNull(bootPath);

        ClasspathInfo cpInfo = ClasspathInfo.create(bootPath, compilePath, sourcePath);

        JavaSource javaSource = JavaSource.create(cpInfo, fakeFO);

        Task<WorkingCopy> task = new Task<WorkingCopy>() {

            public void cancel() {

            }

            public void run(WorkingCopy workingCopy) throws Exception {

                workingCopy.toPhase(JavaSource.Phase.PARSED);

                TreeMaker make = workingCopy.getTreeMaker();

                String path = "zoo/Krtek.java";

                GeneratorUtilities genUtils = GeneratorUtilities.get(workingCopy);

                CompilationUnitTree newTree = genUtils.createFromTemplate(sourceRoot, path, ElementKind.CLASS);

                MethodTree nju = make.Method(

                        make.Modifiers(Collections.<Modifier>emptySet()),

                        "m",

                        make.PrimitiveType(TypeKind.VOID), // return type - void

                        Collections.<TypeParameterTree>emptyList(),

                        Collections.<VariableTree>emptyList(),

                        Collections.<ExpressionTree>emptyList(),

                        make.Block(Collections.<StatementTree>emptyList(), false),

                        null // default value - not applicable

                );

                ClassTree clazz = make.Class(

                        make.Modifiers(Collections.<Modifier>singleton(Modifier.PUBLIC)),

                        "Krtek",

                        Collections.<TypeParameterTree>emptyList(),

                        null,

                        Collections.<Tree>emptyList(),

                        Collections.singletonList(nju)

                );

                workingCopy.rewrite(null, newTree);

                if(newTree.getTypeDecls().isEmpty()) {

                    make.addCompUnitTypeDecl(newTree, clazz);

                } else {

                    Tree templateClass = newTree.getTypeDecls().get(0);

                    genUtils.copyComments(templateClass, clazz, true);

                    genUtils.copyComments(templateClass, clazz, false);

                    workingCopy.rewrite(templateClass, clazz);

                }

            }

        };

        ModificationResult result = javaSource.runModificationTask(task);

        result.commit();

        String golden =

            "package zoo;\n" +

            "\n" +

            "\n" + // XXX:

            "/**\n * trida\n */\n" +

            "public class Krtek {\n" +

            "\n" +

            "    void m() {\n" +

            "    }\n" +

            "}\n";

        String res = TestUtilities.copyFileToString(new File(getDataDir().getAbsolutePath() + "/zoo/Krtek.java"));

        assertEquals(golden, res);

    }