/** 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;
  }
Example #7
0
 /**
  * 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);
 }
Example #8
0
 /**
  * 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);
 }
Example #9
0
 /**
  * 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);
 }
Example #10
0
 /**
  * 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);
 }
Example #11
0
 /**
  * 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);
 }
Example #12
0
 /**
  * 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);
 }
Example #13
0
 /**
  * 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);
 }
Example #14
0
 /**
  * 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);
 }
Example #15
0
 /**
  * Log a warning message.
  *
  * @param Object message to log
  */
 public static void warn(Object message) {
   RuntimeSingleton.warn(message);
 }
Example #16
0
 /**
  * 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);
 }
Example #17
0
 /**
  * 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);
 }
Example #18
0
 /**
  * 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);
 }
Example #19
0
 /**
  * Initialize the Velocity Runtime with the name of ExtendedProperties object.
  *
  * @param Properties
  */
 public static void init(String configurationFile) throws Exception {
   RuntimeSingleton.init(configurationFile);
 }
Example #20
0
 /**
  * Initialize the Velocity Runtime with a Properties object.
  *
  * @param Properties
  */
 public static void init(Properties p) throws Exception {
   RuntimeSingleton.init(p);
 }
Example #21
0
 /**
  * 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);
 }
Example #22
0
 /**
  * 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);
 }
Example #23
0
 /**
  * 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);
 }
Example #24
0
 /**
  * Log an error message.
  *
  * @param Object message to log
  */
 public static void error(Object message) {
   RuntimeSingleton.error(message);
 }
Example #25
0
 /**
  * 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);
 }
Example #26
0
 /**
  * Log a debug message.
  *
  * @param Object message to log
  */
 public static void debug(Object message) {
   RuntimeSingleton.debug(message);
 }
Example #27
0
 /**
  * Return the velocity runtime configuration object.
  *
  * @return ExtendedProperties configuration object which houses the velocity runtime properties.
  */
 public static ExtendedProperties getConfiguration() {
   return RuntimeSingleton.getConfiguration();
 }
Example #28
0
 /**
  * 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);
 }
Example #29
0
 /**
  * Log an info message.
  *
  * @param Object message to log
  */
 public static void info(Object message) {
   RuntimeSingleton.info(message);
 }
Example #30
0
 /**
  * Clear the values pertaining to a particular property.
  *
  * @param String key of property to clear
  */
 public static void clearProperty(String key) {
   RuntimeSingleton.clearProperty(key);
 }