package org.apache.maven.archetype.old;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import org.apache.maven.archetype.ArchetypeGenerationRequest;
import org.apache.maven.archetype.old.descriptor.ArchetypeDescriptor;
import org.apache.maven.archetype.old.descriptor.ArchetypeDescriptorBuilder;
import org.apache.maven.archetype.old.descriptor.TemplateDescriptor;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.archetype.common.ArchetypeArtifactManager;
import org.apache.maven.archetype.common.Constants;
import org.apache.maven.archetype.exception.UnknownArchetype;
import org.apache.maven.model.Build;
import org.apache.maven.model.Model;
import org.apache.maven.model.Parent;
import org.apache.maven.model.Resource;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.apache.maven.model.io.xpp3.MavenXpp3Writer;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.context.Context;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.component.annotations.Requirement;
import org.codehaus.plexus.logging.AbstractLogEnabled;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.WriterFactory;
import org.codehaus.plexus.util.xml.XmlStreamReader;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import org.codehaus.plexus.velocity.VelocityComponent;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/**
* @author <a href="mailto:jason@maven.org">Jason van Zyl</a>
* @version $Id: DefaultOldArchetype.java 1178556 2011-10-03 20:28:14Z hboutemy $
*/
@Component( role = OldArchetype.class )
public class DefaultOldArchetype
extends AbstractLogEnabled
implements OldArchetype
{
private static final String DEFAULT_TEST_RESOURCE_DIR = "/src/test/resources";
private static final String DEFAULT_TEST_SOURCE_DIR = "/src/test/java";
private static final String DEFAULT_RESOURCE_DIR = "/src/main/resources";
private static final String DEFAULT_SOURCE_DIR = "/src/main/java";
// ----------------------------------------------------------------------
// Components
// ----------------------------------------------------------------------
@Requirement
private VelocityComponent velocity;
@Requirement
private ArchetypeArtifactManager archetypeArtifactManager;
// ----------------------------------------------------------------------
// Implementation
// ----------------------------------------------------------------------
// groupId = maven
// artifactId = maven-foo-archetype
// version = latest
public void createArchetype( ArchetypeGenerationRequest request, ArtifactRepository archetypeRepository )
throws UnknownArchetype, ArchetypeNotFoundException, ArchetypeDescriptorException,
ArchetypeTemplateProcessingException
{
// ----------------------------------------------------------------------
// Download the archetype
// ----------------------------------------------------------------------
File archetypeFile = archetypeArtifactManager.getArchetypeFile(
request.getArchetypeGroupId(), request.getArchetypeArtifactId(), request.getArchetypeVersion(),
archetypeRepository, request.getLocalRepository(), request.getRemoteArtifactRepositories() );
createArchetype( request, archetypeFile );
}
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() );
// ---------------------------------------------------------------------
// Get Logger and display all parameters used
// ---------------------------------------------------------------------
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 );
}
}
}
// ----------------------------------------------------------------------
// Log message on OldArchetype creation
// ----------------------------------------------------------------------
if ( getLogger().isInfoEnabled() )
{
getLogger().info( "project created from Old (1.x) Archetype in dir: " + outputDirectory );
}
}
static boolean addModuleToParentPom( String artifactId, Reader fileReader, Writer fileWriter )
throws DocumentException, IOException, ArchetypeTemplateProcessingException
{
SAXReader reader = new SAXReader();
Document document = reader.read( fileReader );
Element project = document.getRootElement();
String packaging = null;
Element packagingElement = project.element( "packaging" );
if ( packagingElement != null )
{
packaging = packagingElement.getStringValue();
}
if ( !"pom".equals( packaging ) )
{
throw new ArchetypeTemplateProcessingException(
"Unable to add module to the current project as it is not of packaging type 'pom'" );
}
Element modules = project.element( "modules" );
if ( modules == null )
{
modules = project.addText( " " ).addElement( "modules" );
modules.setText( "\n " );
project.addText( "\n" );
}
boolean found = false;
for ( Iterator<?> i = modules.elementIterator( "module" ); i.hasNext() && !found; )
{
Element module = (Element) i.next();
if ( module.getText().equals( artifactId ) )
{
found = true;
}
}
if ( !found )
{
Node lastTextNode = null;
for ( Iterator<?> i = modules.nodeIterator(); i.hasNext(); )
{
Node node = (Node) i.next();
if ( node.getNodeType() == Node.ELEMENT_NODE )
{
lastTextNode = null;
}
else if ( node.getNodeType() == Node.TEXT_NODE )
{
lastTextNode = node;
}
}
if ( lastTextNode != null )
{
modules.remove( lastTextNode );
}
modules.addText( "\n " );
modules.addElement( "module" ).setText( artifactId );
modules.addText( "\n " );
XMLWriter writer = new XMLWriter( fileWriter );
writer.write( document );
}
return !found;
}
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 ***********************" );
// ----------------------------------------------------------------------
// Main
// ----------------------------------------------------------------------
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 );
}
// ----------------------------------------------------------------------
// Test
// ----------------------------------------------------------------------
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 );
}
// ----------------------------------------------------------------------
// Site
// ----------------------------------------------------------------------
if ( descriptor.getSiteResources().size() > 0 )
{
processSiteResources( outputDirectory, context, descriptor, packageName );
}
}
private void processTemplate( String outputDirectory, Context context, String template,
TemplateDescriptor descriptor, boolean packageInFileName, String packageName )
throws ArchetypeTemplateProcessingException
{
processTemplate( outputDirectory, context, template, descriptor, packageInFileName, packageName, null );
}
private String getOutputDirectory( String outputDirectory, String testResourceDirectory )
{
return outputDirectory
+ ( testResourceDirectory.startsWith( "/" ) ? testResourceDirectory : "/" + testResourceDirectory );
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
protected void processSources( String outputDirectory, Context context, ArchetypeDescriptor descriptor,
String packageName, String sourceDirectory )
throws ArchetypeTemplateProcessingException
{
for ( String template : descriptor.getSources() )
{
processTemplate( outputDirectory, context, template, descriptor.getSourceDescriptor( template ), true,
packageName, sourceDirectory );
}
}
protected void processTestSources( String outputDirectory, Context context, ArchetypeDescriptor descriptor,
String packageName, String testSourceDirectory )
throws ArchetypeTemplateProcessingException
{
for ( String template : descriptor.getTestSources() )
{
processTemplate( outputDirectory, context, template, descriptor.getTestSourceDescriptor( template ), true,
packageName, testSourceDirectory );
}
}
protected void processResources( String outputDirectory, Context context, ArchetypeDescriptor descriptor,
String packageName )
throws ArchetypeTemplateProcessingException
{
for ( String template : descriptor.getResources() )
{
processTemplate( outputDirectory, context, template, descriptor.getResourceDescriptor( template ), false,
packageName );
}
}
protected void processTestResources( String outputDirectory, Context context, ArchetypeDescriptor descriptor,
String packageName )
throws ArchetypeTemplateProcessingException
{
for ( String template : descriptor.getTestResources() )
{
processTemplate( outputDirectory, context, template, descriptor.getTestResourceDescriptor( template ),
false, packageName );
}
}
protected void processSiteResources( String outputDirectory, Context context, ArchetypeDescriptor descriptor,
String packageName )
throws ArchetypeTemplateProcessingException
{
for ( String template : descriptor.getSiteResources() )
{
processTemplate( outputDirectory, context, template, descriptor.getSiteResourceDescriptor( template ),
false, packageName );
}
}
protected void processTemplate( String outputDirectory, Context context, String template,
TemplateDescriptor descriptor, boolean packageInFileName, String packageName,
String sourceDirectory )
throws ArchetypeTemplateProcessingException
{
File f;
template = StringUtils.replace( template, "\\", "/" );
if ( packageInFileName && packageName != null )
{
String templateFileName = StringUtils.replace( template, "/", File.separator );
String path = packageName.replace( '.', '/' );
String filename = FileUtils.filename( templateFileName );
String dirname = FileUtils.dirname( templateFileName ).replace( '\\', '/' );
sourceDirectory = sourceDirectory.replace( '\\', '/' );
if ( sourceDirectory.startsWith( "/" ) )
{
sourceDirectory = sourceDirectory.substring( 1 );
}
if ( !dirname.startsWith( sourceDirectory ) )
{
throw new ArchetypeTemplateProcessingException(
"Template '" + template + "' not in directory '" + sourceDirectory + "'" );
}
String extraPackages = dirname.substring( sourceDirectory.length() );
if ( extraPackages.startsWith( "/" ) )
{
extraPackages = extraPackages.substring( 1 );
}
if ( extraPackages.length() > 0 )
{
path += "/" + extraPackages;
}
f = new File( new File( new File( outputDirectory, sourceDirectory ), path ), filename );
}
else
{
f = new File( outputDirectory, template );
}
if ( !f.getParentFile().exists() )
{
f.getParentFile().mkdirs();
}
if ( descriptor.isFiltered() )
{
Writer writer = null;
try
{
StringWriter stringWriter = new StringWriter();
template = ARCHETYPE_RESOURCES + "/" + template;
velocity.getEngine().mergeTemplate( template, descriptor.getEncoding(), context, stringWriter );
writer = new OutputStreamWriter( new FileOutputStream( f ), descriptor.getEncoding() );
writer.write( StringUtils.unifyLineSeparators( stringWriter.toString() ) );
writer.flush();
}
catch ( Exception e )
{
throw new ArchetypeTemplateProcessingException( "Error merging velocity templates", e );
}
finally
{
IOUtil.close( writer );
}
}
else
{
InputStream is = getStream( ARCHETYPE_RESOURCES + "/" + template, null );
OutputStream fos = null;
try
{
fos = new FileOutputStream( f );
IOUtil.copy( is, fos );
}
catch ( Exception e )
{
throw new ArchetypeTemplateProcessingException( "Error copying file", e );
}
finally
{
IOUtil.close( fos );
IOUtil.close( is );
}
}
}
protected void createProjectDirectoryStructure( String outputDirectory )
{
}
private InputStream getStream( String name, ClassLoader loader )
{
if ( loader == null )
{
return Thread.currentThread().getContextClassLoader().getResourceAsStream( name );
}
return loader.getResourceAsStream( name );
}
}