/** Runs the test. */
public void runTest() {
try {
String curdir = System.getProperty("user.dir");
String f = getFileName(curdir, TEMPLATE_PATH, TMPL_FILE_EXT);
System.out.println("Retrieving template at absolute path: " + f);
Template template1 = RuntimeSingleton.getTemplate(f);
FileOutputStream fos1 =
new FileOutputStream(getFileName(RESULTS_DIR, "absolute", RESULT_FILE_EXT));
Writer writer1 = new BufferedWriter(new OutputStreamWriter(fos1));
/*
* put the Vector into the context, and merge both
*/
VelocityContext context = new VelocityContext();
template1.merge(context, writer1);
writer1.flush();
writer1.close();
if (!isMatch(RESULTS_DIR, COMPARE_DIR, "absolute", RESULT_FILE_EXT, CMP_FILE_EXT)) {
fail("Output incorrect.");
}
} catch (Exception e) {
fail(e.getMessage());
}
}
@Override
public String getRepresentationForContent(Content content) {
StringWriter writer = new StringWriter();
ctx.put("content", content);
try {
RuntimeSingleton.getRuntimeInstance().render(ctx, writer, "some.vm", simpleNode);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
return writer.toString();
}
public VelocityTemplateRepresentationGenerator(byte[] templateData)
throws InvalidTemplateException {
try {
this.simpleNode =
RuntimeSingleton.parse(
new InputStreamReader(new ByteArrayInputStream(templateData)), "some.vm");
} catch (Exception ex) {
logger.warn(ex.getMessage(), ex);
throw new InvalidTemplateException(ex);
}
if (simpleNode == null) {
throw new InvalidTemplateException();
}
}
public DBContextTest(String templateFile) {
try {
RuntimeSingleton.init(new Properties());
Template template = RuntimeSingleton.getTemplate(templateFile);
DBContext dbc = new DBContext();
Hashtable h = new Hashtable();
h.put("Bar", "this is from a hashtable!");
dbc.put("string", "Hello!");
dbc.put("hashtable", h);
Writer writer = new BufferedWriter(new OutputStreamWriter(System.out));
template.merge(dbc, writer);
writer.flush();
writer.close();
} catch (Exception e) {
RuntimeSingleton.error(e);
}
}
private String render(VelocityContext context, String template) {
RuntimeServices runtimeServices = RuntimeSingleton.getRuntimeServices();
StringReader reader = new StringReader(template);
SimpleNode node;
try {
node = runtimeServices.parse(reader, "Template name");
} catch (ParseException e) {
throw new ServerError(e);
}
Template t = new Template();
t.setRuntimeServices(runtimeServices);
t.setData(node);
t.initDocument();
StringWriter writer = new StringWriter();
t.merge(context, writer);
writer.write("\n\n\n\n\n");
return writer.toString();
}
/**
* Constructor based on a Velocity 'encoded' representation.
*
* @param templateRepresentation The representation to 'decode'.
* @param mediaType The representation's media type.
* @throws IOException
* @throws ParseErrorException
* @throws ResourceNotFoundException
*/
public TemplateRepresentation(Representation templateRepresentation, MediaType mediaType)
throws ResourceNotFoundException, ParseErrorException, IOException {
super(mediaType);
this.engine = null;
this.template = new Template();
CharacterSet charSet =
(templateRepresentation.getCharacterSet() != null)
? templateRepresentation.getCharacterSet()
: CharacterSet.DEFAULT;
this.template.setEncoding(charSet.getName());
this.template.setLastModified(
(templateRepresentation.getModificationDate() == null)
? new Date().getTime()
: templateRepresentation.getModificationDate().getTime());
this.template.setName("org.restlet.resource.representation");
this.template.setRuntimeServices(RuntimeSingleton.getRuntimeServices());
this.template.setResourceLoader(new RepresentationResourceLoader(templateRepresentation));
this.template.process();
this.templateName = null;
}
/**
* Checks to see if a VM exists
*
* @param name Name of velocimacro
* @return boolean True if VM by that name exists, false if not
*/
public static boolean isVelocimacro(String vmName, String templateName) {
return RuntimeSingleton.isVelocimacro(vmName, templateName);
}
/**
* Returns the appropriate VelocimacroProxy object if strVMname is a valid current Velocimacro.
*
* @param String vmName Name of velocimacro requested
* @return String VelocimacroProxy
*/
public static Directive getVelocimacro(String vmName, String templateName) {
return RuntimeSingleton.getVelocimacro(vmName, templateName);
}
/**
* Adds a new Velocimacro. Usually called by Macro only while parsing.
*
* @param String name Name of velocimacro
* @param String macro String form of macro body
* @param String argArray Array of strings, containing the #macro() arguments. the 0th is the
* name.
* @return boolean True if added, false if rejected for some reason (either parameters or
* permission settings)
*/
public static boolean addVelocimacro(
String name, String macro, String argArray[], String sourceTemplate) {
return RuntimeSingleton.addVelocimacro(name, macro, argArray, sourceTemplate);
}
/**
* Allow an external system to set an ExtendedProperties object to use. This is useful where the
* external system also uses the ExtendedProperties class and the velocity configuration is a
* subset of parent application's configuration. This is the case with Turbine.
*
* @param ExtendedProperties configuration
*/
public static void setConfiguration(ExtendedProperties configuration) {
RuntimeSingleton.setConfiguration(configuration);
}
/**
* Allows an external caller to get a property. The calling routine is required to know the type,
* as this routine will return an Object, as that is what properties can be.
*
* @param key property to return
*/
public static Object getProperty(String key) {
return RuntimeSingleton.getProperty(key);
}
/**
* Int property accessor method to hide the configuration implementation.
*
* @param String key property key
* @return int value
*/
public static int getInt(String key) {
return RuntimeSingleton.getInt(key);
}
/**
* Boolean property accessor method to hide the configuration implementation.
*
* @param String key property key
* @param boolean default default value if property not found
* @return boolean value of key or default value
*/
public static boolean getBoolean(String key, boolean def) {
return RuntimeSingleton.getBoolean(key, def);
}
/**
* Determines is a template exists, and returns name of the loader that provides it. This is a
* slightly less hokey way to support the Velocity.templateExists() utility method, which was
* broken when per-template encoding was introduced. We can revisit this.
*
* @param resourceName Name of template or content resource
* @return class name of loader than can provide it
*/
public static String getLoaderNameForResource(String resourceName) {
return RuntimeSingleton.getLoaderNameForResource(resourceName);
}
/**
* Log a warning message.
*
* @param Object message to log
*/
public static void warn(Object message) {
RuntimeSingleton.warn(message);
}
/**
* Returns a <code>Template</code> from the resource manager
*
* @param name The name of the desired template.
* @param encoding Character encoding of the template
* @return The template.
* @throws ResourceNotFoundException if template not found from any available source.
* @throws ParseErrorException if template cannot be parsed due to syntax (or other) error.
* @throws Exception if an error occurs in template initialization
*/
public static Template getTemplate(String name, String encoding)
throws ResourceNotFoundException, ParseErrorException, Exception {
return RuntimeSingleton.getTemplate(name, encoding);
}
/**
* Returns a static content resource from the resource manager.
*
* @param name Name of content resource to get
* @param encoding Character encoding to use
* @return parsed ContentResource object ready for use
* @throws ResourceNotFoundException if template not found from any available source.
*/
public static ContentResource getContent(String name, String encoding)
throws ResourceNotFoundException, ParseErrorException, Exception {
return RuntimeSingleton.getContent(name, encoding);
}
/**
* Parse the input and return the root of the AST node structure.
*
* @param InputStream inputstream retrieved by a resource loader
* @param String name of the template being parsed
* @param dumpNamespace flag to dump the Velocimacro namespace for this template
*/
public static SimpleNode parse(Reader reader, String templateName, boolean dumpNamespace)
throws ParseException {
return RuntimeSingleton.parse(reader, templateName, dumpNamespace);
}
/**
* Initialize the Velocity Runtime with the name of ExtendedProperties object.
*
* @param Properties
*/
public static void init(String configurationFile) throws Exception {
RuntimeSingleton.init(configurationFile);
}
/**
* Initialize the Velocity Runtime with a Properties object.
*
* @param Properties
*/
public static void init(Properties p) throws Exception {
RuntimeSingleton.init(p);
}
/**
* tells the vmFactory to dump the specified namespace. This is to support clearing the VM list
* when in inline-VM-local-scope mode
*/
public static boolean dumpVMNamespace(String namespace) {
return RuntimeSingleton.dumpVMNamespace(namespace);
}
/**
* Add a property to the configuration. If it already exists then the value stated here will be
* added to the configuration entry. For example, if
*
* <p>resource.loader = file
*
* <p>is already present in the configuration and you
*
* <p>addProperty("resource.loader", "classpath")
*
* <p>Then you will end up with a Vector like the following:
*
* <p>["file", "classpath"]
*
* @param String key
* @param String value
*/
public static void addProperty(String key, Object value) {
RuntimeSingleton.addProperty(key, value);
}
/**
* String property accessor method to hide the configuration implementation
*
* @param key property key
* @return value of key or null
*/
public static String getString(String key) {
return RuntimeSingleton.getString(key);
}
/**
* Log an error message.
*
* @param Object message to log
*/
public static void error(Object message) {
RuntimeSingleton.error(message);
}
/**
* Int property accessor method to hide the configuration implementation.
*
* @param key property key
* @param int default value
* @return int value
*/
public static int getInt(String key, int defaultValue) {
return RuntimeSingleton.getInt(key, defaultValue);
}
/**
* Log a debug message.
*
* @param Object message to log
*/
public static void debug(Object message) {
RuntimeSingleton.debug(message);
}
/**
* Return the velocity runtime configuration object.
*
* @return ExtendedProperties configuration object which houses the velocity runtime properties.
*/
public static ExtendedProperties getConfiguration() {
return RuntimeSingleton.getConfiguration();
}
/**
* String property accessor method with default to hide the configuration implementation.
*
* @param String key property key
* @param String defaultValue default value to return if key not found in resource manager.
* @return String value of key or default
*/
public static String getString(String key, String defaultValue) {
return RuntimeSingleton.getString(key, defaultValue);
}
/**
* Log an info message.
*
* @param Object message to log
*/
public static void info(Object message) {
RuntimeSingleton.info(message);
}
/**
* Clear the values pertaining to a particular property.
*
* @param String key of property to clear
*/
public static void clearProperty(String key) {
RuntimeSingleton.clearProperty(key);
}