Open Source Repository

Home /beanshell/bsh-2.0b4 | Repository Home


bsh/servlet/SimpleTemplate.java
package bsh.servlet;

/**

  This file is derived from Pat Niemeyer's free utilities package.  
  Now part of BeanShell.

  @see http://www.pat.net/javautil/
  @version 1.0
  @author Pat Niemeyer (pat@pat.net)
*/

import java.io.*;
import java.util.*;
import java.net.URL;

/**
  This is  a simple template engine.  An instance of SimpleTemplate wraps
  a StringBuffer and performs replace operations on one or more parameters
  embedded as HMTL style comments. The value can then be retrieved as a 
  String or written to a stream.

  Template values  in the text are  of the form:

    <!-- TEMPLATE-NAME -->

  Substitutions then take  the form of:

    template.replace( "NAME", value  );

  Two static util  methods  are provided to  help read the text of a  template
  from a stream (perhaps a URL or  resource).  e.g.

  @author  Pat Niemeyer
*/
public class SimpleTemplate 
{
  StringBuffer buff;
  static String NO_TEMPLATE = "NO_TEMPLATE";  // Flag  for non-existent
  static Map templateData  = new HashMap();
  static boolean cacheTemplates =  true;

  /**
    Get a template by name, with caching.
    Note: this should be updated to search the resource path first, etc.

    Create a new instance of a template from the specified file.

    The file text is cached  so lookup is fast.  Failure to find the
    file is  also cached so the read  will not happen  twice.

  */
  public static SimpleTemplate getTemplateString file )
  {
    String templateText = (String)templateData.get(  file );

    if templateText == null || !cacheTemplates ) {
      try {
        FileReader fr =  new FileReader(  file );
        templateText = SimpleTemplate.getStringFromStreamfr );
        templateData.putfile,  templateText );
      catch  IOException e  ) {
        // Not found
        templateData.putfile,  NO_TEMPLATE );
      }
    else
      // Quick check prevents  trying each time
      if templateText.equalsNO_TEMPLATE )  )
        return null;

    if templateText == null )
      return null;
    else
      return new SimpleTemplatetemplateText  );
  }

  public static String getStringFromStreamInputStream ins )
    throws IOException
  {
    return getStringFromStreamnew  InputStreamReaderins ) );
  }

  public static String getStringFromStreamReader reader  throws IOException {
    StringBuffer sb  = new StringBuffer();
    BufferedReader br = new  BufferedReader(  reader );
    String line;
    while (  ( line = br.readLine() ) != null )
      sb.appendline  +"\n");

    return sb.toString();
  }

  public SimpleTemplateString template ) {
    init(template);
  }

  public SimpleTemplateReader reader throws IOException {
    String template  = getStringFromStreamreader );
    init(template);
  }

  public SimpleTemplateURL url throws IOException 
  {
    String template  = getStringFromStreamurl.openStream() );
    init(template);
  }

  private void initString s ) {
    buff = new StringBuffer);
  }

  /**
    Substitute the specified text for the parameter
  */
  public void replaceString param, String value  ) {
    int [] range;
    while (  (range = findTemplateparam ))  != null  )
      buff.replacerange[0],  range[1], value  );
  }

  /**
    Find the starting (inclusive) and ending (exclusive) index of the
    named template and return them as a two  element  int [].
    Or return null if the param is not found.
  */
  int [] findTemplateString name ) {
    String text = buff.toString();
    int len  = text.length();

    int start = 0;

    while (  start <  len ) {

      // Find  begin and end comment
      int cstart = text.indexOf"<!--", start );
      if cstart == -)
        return null;  // no more comments
      int cend = text.indexOf"-->",  cstart );
      if cend == -1  )
        return null;  // no more complete comments
      cend +=  "-->".length();

      // Find  template tag
      int tstart = text.indexOf"TEMPLATE-",  cstart );
      if tstart == -) {
        start =  cend; // try the next comment
        continue;
      }

      // Is the tag inside the comment we found?
      if tstart > cend ) {
        start =  cend; // try the next comment
        continue;
      }

      // find  begin and end of param name
      int pstart = tstart + "TEMPLATE-".length();

      int pend = len;
      for pend = pstart; pend < len; pend++) {
        char c = text.charAtpend );
        if c == ' ' || c == '\t' || c  == '-' )
          break;
      }
      if pend >= len )
        return null;

      String param = text.substringpstart, pend );

      // If it's the correct one, return the comment extent
      if param.equalsname  ) )
        return new int [] { cstart, cend };

//System.out.println( "Found param: {"+param+"}  in comment: "+ text.substring(cstart, cend) +"}");
      // Else  try the  next one
      start =  cend;
    }

    // Not found
    return null;
  }

  public String toString() {
    return buff.toString();
  }

  public void writePrintWriter out ) {
    out.printlntoString()  );
  }

  public void writePrintStream out ) {
    out.printlntoString()  );
  }

  /**
    usage: filename  param value
  */
  public static void mainString  [] args  throws IOException
  {
    String filename  = args[0];
    String param = args[1];
    String value = args[2];

    FileReader fr =  new FileReader(  filename );
    String templateText = SimpleTemplate.getStringFromStreamfr );
    SimpleTemplate template  = new SimpleTemplatetemplateText );

    template.replaceparam, value );
    template.write(  System.out );
  }

  public static void setCacheTemplatesboolean b  ) {
    cacheTemplates = b;
  }

}