use of org.apache.maven.model.io.xpp3.MavenXpp3Reader in project maven-archetype by apache.
the class DefaultOldArchetype method processTemplates.
private void processTemplates(File pomFile, String outputDirectory, Context context, ArchetypeDescriptor descriptor, String packageName, Model parentModel) throws ArchetypeTemplateProcessingException {
if (!pomFile.exists()) {
processTemplate(outputDirectory, context, ARCHETYPE_POM, new TemplateDescriptor(), false, null);
}
// ---------------------------------------------------------------------
// Model generated for the new archetype, so process it now
// ---------------------------------------------------------------------
Model generatedModel;
Reader pomReader = null;
try {
pomReader = ReaderFactory.newXmlReader(pomFile);
MavenXpp3Reader reader = new MavenXpp3Reader();
generatedModel = reader.read(pomReader);
} catch (IOException e) {
throw new ArchetypeTemplateProcessingException("Error reading POM", e);
} catch (XmlPullParserException e) {
throw new ArchetypeTemplateProcessingException("Error reading POM", e);
} finally {
IOUtil.close(pomReader);
}
if (parentModel != null) {
Parent parent = new Parent();
parent.setGroupId(parentModel.getGroupId());
if (parent.getGroupId() == null) {
parent.setGroupId(parentModel.getParent().getGroupId());
}
parent.setArtifactId(parentModel.getArtifactId());
parent.setVersion(parentModel.getVersion());
if (parent.getVersion() == null) {
parent.setVersion(parentModel.getParent().getVersion());
}
generatedModel.setParent(parent);
Writer pomWriter = null;
try {
pomWriter = WriterFactory.newXmlWriter(pomFile);
MavenXpp3Writer writer = new MavenXpp3Writer();
writer.write(pomWriter, generatedModel);
} catch (IOException e) {
throw new ArchetypeTemplateProcessingException("Error rewriting POM", e);
} finally {
IOUtil.close(pomWriter);
}
}
// XXX: Following POM processing block may be a candidate for
// refactoring out into service methods or moving to
// createProjectDirectoryStructure(outputDirectory)
Build build = generatedModel.getBuild();
boolean overrideSrcDir = false;
boolean overrideResourceDir = false;
boolean overrideTestSrcDir = false;
boolean overrideTestResourceDir = false;
boolean foundBuildElement = build != null;
if (getLogger().isDebugEnabled()) {
getLogger().debug("********************* Debug info for resources created from generated Model ***********************");
getLogger().debug("Was build element found in generated POM?: " + foundBuildElement);
}
// create source directory if specified in POM
if (foundBuildElement && null != build.getSourceDirectory()) {
getLogger().debug("Overriding default source directory ");
overrideSrcDir = true;
String srcDirectory = build.getSourceDirectory();
srcDirectory = StringUtils.replace(srcDirectory, "\\", "/");
FileUtils.mkdir(getOutputDirectory(outputDirectory, srcDirectory));
}
// create script source directory if specified in POM
if (foundBuildElement && null != build.getScriptSourceDirectory()) {
getLogger().debug("Overriding default script source directory ");
String scriptSourceDirectory = build.getScriptSourceDirectory();
scriptSourceDirectory = StringUtils.replace(scriptSourceDirectory, "\\", "/");
FileUtils.mkdir(getOutputDirectory(outputDirectory, scriptSourceDirectory));
}
// create resource director(y/ies) if specified in POM
if (foundBuildElement && build.getResources().size() > 0) {
getLogger().debug("Overriding default resource directory ");
overrideResourceDir = true;
Iterator<?> resourceItr = build.getResources().iterator();
while (resourceItr.hasNext()) {
Resource resource = (Resource) resourceItr.next();
String resourceDirectory = resource.getDirectory();
resourceDirectory = StringUtils.replace(resourceDirectory, "\\", "/");
FileUtils.mkdir(getOutputDirectory(outputDirectory, resourceDirectory));
}
}
// create test source directory if specified in POM
if (foundBuildElement && null != build.getTestSourceDirectory()) {
getLogger().debug("Overriding default test directory ");
overrideTestSrcDir = true;
String testDirectory = build.getTestSourceDirectory();
testDirectory = StringUtils.replace(testDirectory, "\\", "/");
FileUtils.mkdir(getOutputDirectory(outputDirectory, testDirectory));
}
// create test resource directory if specified in POM
if (foundBuildElement && build.getTestResources().size() > 0) {
getLogger().debug("Overriding default test resource directory ");
overrideTestResourceDir = true;
Iterator<?> testResourceItr = build.getTestResources().iterator();
while (testResourceItr.hasNext()) {
Resource resource = (Resource) testResourceItr.next();
String testResourceDirectory = resource.getDirectory();
testResourceDirectory = StringUtils.replace(testResourceDirectory, "\\", "/");
FileUtils.mkdir(getOutputDirectory(outputDirectory, testResourceDirectory));
}
}
getLogger().debug("********************* End of debug info from resources from generated POM ***********************");
if (descriptor.getSources().size() > 0) {
if (!overrideSrcDir) {
FileUtils.mkdir(outputDirectory + DEFAULT_SOURCE_DIR);
processSources(outputDirectory, context, descriptor, packageName, DEFAULT_SOURCE_DIR);
} else {
processSources(outputDirectory, context, descriptor, packageName, build.getSourceDirectory());
}
}
if (descriptor.getResources().size() > 0) {
if (!overrideResourceDir) {
FileUtils.mkdir(outputDirectory + DEFAULT_RESOURCE_DIR);
}
processResources(outputDirectory, context, descriptor, packageName);
}
if (descriptor.getTestSources().size() > 0) {
if (!overrideTestSrcDir) {
FileUtils.mkdir(outputDirectory + DEFAULT_TEST_SOURCE_DIR);
processTestSources(outputDirectory, context, descriptor, packageName, DEFAULT_TEST_SOURCE_DIR);
} else {
processTestSources(outputDirectory, context, descriptor, packageName, build.getTestSourceDirectory());
}
}
if (descriptor.getTestResources().size() > 0) {
if (!overrideTestResourceDir) {
FileUtils.mkdir(outputDirectory + DEFAULT_TEST_RESOURCE_DIR);
}
processTestResources(outputDirectory, context, descriptor, packageName);
}
if (descriptor.getSiteResources().size() > 0) {
processSiteResources(outputDirectory, context, descriptor, packageName);
}
}
use of org.apache.maven.model.io.xpp3.MavenXpp3Reader in project maven-archetype by apache.
the class DefaultOldArchetype method createArchetype.
public void createArchetype(ArchetypeGenerationRequest request, File archetypeFile) throws ArchetypeDescriptorException, ArchetypeTemplateProcessingException {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("basedir", request.getOutputDirectory());
parameters.put(Constants.PACKAGE, request.getPackage());
parameters.put("packageName", request.getPackage());
parameters.put(Constants.GROUP_ID, request.getGroupId());
parameters.put(Constants.ARTIFACT_ID, request.getArtifactId());
parameters.put(Constants.VERSION, request.getVersion());
// ---------------------------------------------------------------------
if (getLogger().isInfoEnabled()) {
getLogger().info("----------------------------------------------------------------------------");
getLogger().info("Using following parameters for creating project from Old (1.x) Archetype: " + request.getArchetypeArtifactId() + ":" + request.getArchetypeVersion());
getLogger().info("----------------------------------------------------------------------------");
for (Map.Entry<String, String> entry : parameters.entrySet()) {
String parameterName = entry.getKey();
String parameterValue = entry.getValue();
getLogger().info("Parameter: " + parameterName + ", Value: " + parameterValue);
}
}
// ----------------------------------------------------------------------
// Load the descriptor
// ----------------------------------------------------------------------
ArchetypeDescriptorBuilder builder = new ArchetypeDescriptorBuilder();
ArchetypeDescriptor descriptor;
URLClassLoader archetypeJarLoader;
InputStream is = null;
try {
URL[] urls = new URL[1];
urls[0] = archetypeFile.toURL();
archetypeJarLoader = new URLClassLoader(urls);
is = getStream(ARCHETYPE_DESCRIPTOR, archetypeJarLoader);
if (is == null) {
is = getStream(ARCHETYPE_OLD_DESCRIPTOR, archetypeJarLoader);
}
if (is == null) {
throw new ArchetypeDescriptorException("The " + ARCHETYPE_DESCRIPTOR + " descriptor cannot be found.");
}
descriptor = builder.build(new XmlStreamReader(is));
} catch (IOException e) {
throw new ArchetypeDescriptorException("Error reading the " + ARCHETYPE_DESCRIPTOR + " descriptor.", e);
} catch (XmlPullParserException e) {
throw new ArchetypeDescriptorException("Error reading the " + ARCHETYPE_DESCRIPTOR + " descriptor.", e);
} finally {
IOUtil.close(is);
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
String artifactId = request.getArtifactId();
File parentPomFile = new File(request.getOutputDirectory(), ARCHETYPE_POM);
File outputDirectoryFile;
boolean creating;
File pomFile;
if (parentPomFile.exists() && descriptor.isAllowPartial() && artifactId == null) {
outputDirectoryFile = new File(request.getOutputDirectory());
creating = false;
pomFile = parentPomFile;
} else {
if (artifactId == null) {
throw new ArchetypeTemplateProcessingException("Artifact ID must be specified when creating a new project from an archetype.");
}
outputDirectoryFile = new File(request.getOutputDirectory(), artifactId);
creating = true;
if (outputDirectoryFile.exists()) {
if (descriptor.isAllowPartial()) {
creating = false;
} else {
throw new ArchetypeTemplateProcessingException("Directory " + outputDirectoryFile.getName() + " already exists - please run from a clean directory");
}
}
pomFile = new File(outputDirectoryFile, ARCHETYPE_POM);
}
if (creating) {
if (request.getGroupId() == null) {
throw new ArchetypeTemplateProcessingException("Group ID must be specified when creating a new project from an archetype.");
}
if (request.getVersion() == null) {
throw new ArchetypeTemplateProcessingException("Version must be specified when creating a new project from an archetype.");
}
}
String outputDirectory = outputDirectoryFile.getAbsolutePath();
String packageName = request.getPackage();
// ----------------------------------------------------------------------
// Set up the Velocity context
// ----------------------------------------------------------------------
Context context = new VelocityContext();
context.put(Constants.PACKAGE, packageName);
for (Map.Entry<String, String> entry : parameters.entrySet()) {
context.put(entry.getKey(), entry.getValue());
}
// ----------------------------------------------------------------------
// Process the templates
// ----------------------------------------------------------------------
ClassLoader old = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(archetypeJarLoader);
Model parentModel = null;
if (creating) {
if (parentPomFile.exists()) {
Reader fileReader = null;
try {
fileReader = ReaderFactory.newXmlReader(parentPomFile);
MavenXpp3Reader reader = new MavenXpp3Reader();
parentModel = reader.read(fileReader);
if (!"pom".equals(parentModel.getPackaging())) {
throw new ArchetypeTemplateProcessingException("Unable to add module to the current project as it is not of packaging type 'pom'");
}
} catch (IOException e) {
throw new ArchetypeTemplateProcessingException("Unable to read parent POM", e);
} catch (XmlPullParserException e) {
throw new ArchetypeTemplateProcessingException("Unable to read parent POM", e);
} finally {
IOUtil.close(fileReader);
}
parentModel.getModules().add(artifactId);
}
}
try {
processTemplates(pomFile, outputDirectory, context, descriptor, packageName, parentModel);
} finally {
Thread.currentThread().setContextClassLoader(old);
}
if (parentModel != null) {
/*
// TODO: would be nice to just write out with the xpp3 writer again, except that it loses a bunch of info and
// reformats, so the module is just baked in as a string instead.
FileWriter fileWriter = null;
try
{
fileWriter = new FileWriter( parentPomFile );
MavenXpp3Writer writer = new MavenXpp3Writer();
writer.write( fileWriter, parentModel );
}
catch ( IOException e )
{
throw new ArchetypeTemplateProcessingException( "Unable to rewrite parent POM", e );
}
finally
{
IOUtil.close( fileWriter );
}
*/
Reader fileReader = null;
boolean added;
StringWriter w = new StringWriter();
try {
fileReader = ReaderFactory.newXmlReader(parentPomFile);
added = addModuleToParentPom(artifactId, fileReader, w);
} catch (IOException e) {
throw new ArchetypeTemplateProcessingException("Unable to rewrite parent POM", e);
} catch (DocumentException e) {
throw new ArchetypeTemplateProcessingException("Unable to rewrite parent POM", e);
} finally {
IOUtil.close(fileReader);
}
if (added) {
Writer out = null;
try {
out = WriterFactory.newXmlWriter(parentPomFile);
IOUtil.copy(w.toString(), out);
} catch (IOException e) {
throw new ArchetypeTemplateProcessingException("Unable to rewrite parent POM", e);
} finally {
IOUtil.close(out);
}
}
}
// ----------------------------------------------------------------------
if (getLogger().isInfoEnabled()) {
getLogger().info("project created from Old (1.x) Archetype in dir: " + outputDirectory);
}
}
use of org.apache.maven.model.io.xpp3.MavenXpp3Reader in project maven-archetype by apache.
the class DefaultPomManager method readPom.
public Model readPom(InputStream pomStream) throws IOException, XmlPullParserException {
Reader pomReader = ReaderFactory.newXmlReader(pomStream);
MavenXpp3Reader reader = new MavenXpp3Reader();
return reader.read(pomReader);
}
use of org.apache.maven.model.io.xpp3.MavenXpp3Reader in project maven-archetype by apache.
the class DefaultPomManager method readPom.
public Model readPom(final File pomFile) throws IOException, XmlPullParserException {
Model model;
Reader pomReader = null;
try {
pomReader = ReaderFactory.newXmlReader(pomFile);
MavenXpp3Reader reader = new MavenXpp3Reader();
model = reader.read(pomReader);
} finally {
IOUtil.close(pomReader);
}
return model;
}
use of org.apache.maven.model.io.xpp3.MavenXpp3Reader in project maven-archetype by apache.
the class DefaultArchetypeGeneratorTest method readPom.
private Model readPom(final File pomFile) throws IOException, XmlPullParserException {
Reader pomReader = null;
try {
pomReader = ReaderFactory.newXmlReader(pomFile);
MavenXpp3Reader reader = new MavenXpp3Reader();
return reader.read(pomReader);
} finally {
IOUtil.close(pomReader);
}
}
Aggregations