Coverage Report - org.webmacro.WM
 
Classes in this File Line Coverage Branch Coverage Complexity
WM
34%
17/50
25%
1/4
1.476
 
 1  
 /*
 2  
  * Copyright (C) 1998-2000 Semiotek Inc.  All Rights Reserved.
 3  
  *
 4  
  * Redistribution and use in source and binary forms, with or without
 5  
  * modification, are permitted under the terms of either of the following
 6  
  * Open Source licenses:
 7  
  *
 8  
  * The GNU General Public License, version 2, or any later version, as
 9  
  * published by the Free Software Foundation
 10  
  * (http://www.fsf.org/copyleft/gpl.html);
 11  
  *
 12  
  *  or
 13  
  *
 14  
  * The Semiotek Public License (http://webmacro.org/LICENSE.)
 15  
  *
 16  
  * This software is provided "as is", with NO WARRANTY, not even the
 17  
  * implied warranties of fitness to purpose, or merchantability. You
 18  
  * assume all risks and liabilities associated with its use.
 19  
  *
 20  
  * See www.webmacro.org for more information on the WebMacro project.
 21  
  */
 22  
 
 23  
 
 24  
 package org.webmacro;
 25  
 
 26  
 import java.io.OutputStream;
 27  
 import java.io.UnsupportedEncodingException;
 28  
 import java.util.Properties;
 29  
 
 30  
 import javax.servlet.Servlet;
 31  
 import javax.servlet.ServletContext;
 32  
 import javax.servlet.http.HttpServletRequest;
 33  
 import javax.servlet.http.HttpServletResponse;
 34  
 
 35  
 import org.slf4j.Logger;
 36  
 import org.slf4j.LoggerFactory;
 37  
 
 38  
 import org.webmacro.servlet.ServletBroker;
 39  
 import org.webmacro.servlet.WebContext;
 40  
 
 41  
 
 42  
 /**
 43  
  * This class implements the WebMacro Manager interface. You can instantiate
 44  
  * this yourself if you want to use WebMacro in standalone mode, rather than
 45  
  * subclassing from org.webmacro.servlet.WMServlet. This is actually the
 46  
  * same class used by the servlet framework to manage access to the broker
 47  
  * there, so you really don't lose much of anything by choosing to go
 48  
  * standalone by using this object. All you have to do is come up with
 49  
  * your own context objects.
 50  
  */
 51  
 public class WM implements WebMacro
 52  
 {
 53  2
     static Logger _log =  LoggerFactory.getLogger(WM.class);
 54  
 
 55  
     // INIT METHODS--MANAGE ACCESS TO THE BROKER
 56  
 
 57  
     final private Broker _broker;      // cache for rapid access
 58  
 
 59  
     final private Provider _tmplProvider;
 60  
     final private Provider _urlProvider;
 61  
 
 62  
 
 63  
     /**
 64  
      * Constructs a WM which gets its properties (optionally) from the
 65  
      * file WebMacro.properties, as found on the class path.  No servlet
 66  
      * integration.  Templates will be loaded from the class path or from
 67  
      * TemplatePath.   Most users will want to use the WM(Servlet) constructor.
 68  
      */
 69  
     public WM () throws InitException
 70  
     {
 71  224
         this(Broker.getBroker());
 72  224
     }
 73  
 
 74  
     /**
 75  
      * Constructs a WM which gets its properties (optionally) from the
 76  
      * file WebMacro.properties, as found on the class path, and from properties
 77  
      * specified in a provided Properties.  No servlet
 78  
      * integration.  Templates will be loaded from the class path or from
 79  
      * TemplatePath.   Most users will want to use the WM(Servlet) constructor.
 80  
      */
 81  
     public WM (Properties p) throws InitException
 82  
     {
 83  0
         this(Broker.getBroker(p));
 84  0
     }
 85  
 
 86  
     /**
 87  
      * Constructs a WM which gets its properties from the file specified,
 88  
      * which must exist on the class path or be an absolute path.  No servlet
 89  
      * integration.  Templates will be loaded from the class path or from
 90  
      * TemplatePath.  Most users will want to use the WM(Servlet) constructor.
 91  
      */
 92  
     public WM (String config) throws InitException
 93  
     {
 94  0
         this(Broker.getBroker(config));
 95  0
     }
 96  
 
 97  
     /**
 98  
      * Constructs a WM tied to a Servlet broker.  Depending on the
 99  
      * servlet container's level of servlet support, property fetching,
 100  
      * logging, and template fetching will be managed by the servlet broker.
 101  
      */
 102  
     public WM (Servlet s) throws InitException
 103  
     {
 104  32
         this(ServletBroker.getBroker(s));
 105  32
     }
 106  
 
 107  
     /**
 108  
      * Constructs a WM is tied to a Servlet broker, with an additional set of
 109  
      * properties passed in from the caller.
 110  
      */
 111  
     public WM (Servlet s, Properties additionalProperties) throws InitException
 112  
     {
 113  0
         this(ServletBroker.getBroker(s, additionalProperties));
 114  0
     }
 115  
 
 116  
     /**
 117  
      * Constructs a WM is tied to a Servlet broker,
 118  
      * with an additional set of
 119  
      * properties passed in from the caller, using the ServletContext
 120  
      * and ClassLoader provided.
 121  
      * @since 2.1
 122  
      */
 123  
     public WM (ServletContext sc, ClassLoader cl,
 124  
                Properties additionalProperties) throws InitException
 125  
     {
 126  0
         this(ServletBroker.getBroker(sc, cl, additionalProperties));
 127  0
     }
 128  
 
 129  
     /**
 130  
      * Constructs a WM from an arbitrary Broker.  Don't use this unless
 131  
      * you have very specific needs and know what you are doing; constructing
 132  
      * a properly functioning broker is not obvious.
 133  
      */
 134  
     public WM (Broker broker) throws InitException
 135  256
     {
 136  256
         if (broker == null)
 137  0
             throw new InitException("No Broker passed to WM()");
 138  
 
 139  256
         _broker = broker;
 140  256
         _log.info("new " + this + " v" + WebMacro.VERSION);
 141  
 
 142  
         try
 143  
         {
 144  256
             _tmplProvider = _broker.getProvider("template");
 145  256
             _urlProvider = _broker.getProvider("url");
 146  
         }
 147  0
         catch (NotFoundException nfe)
 148  
         {
 149  0
             _log.error("Could not load configuration", nfe);
 150  0
             throw new InitException("Could not locate provider; "
 151  
                     + "This implies that WebMacro is badly misconfigured, you\n"
 152  
                     + "should double check that all configuration files and\n"
 153  
                     + "options are set up correctly. In a default install of\n"
 154  
                     + "WebMacro this likely means your WebMacro.properties file\n"
 155  
                     + "was not found on your CLASSPATH.", nfe);
 156  256
         }
 157  256
     }
 158  
 
 159  
     public String toString ()
 160  
     {
 161  256
         return "WebMacro(" + _broker.getName() + ")";
 162  
     }
 163  
 
 164  
 
 165  
     /**
 166  
      * This object is used to access components that have been plugged
 167  
      * into WebMacro; it is shared between all instances of this class and
 168  
      * its subclasses. It is created when the first instance is initialized,
 169  
      * and deleted when the last instance is shut down. If you attempt to
 170  
      * access it after the last servlet has been shutdown, it will either
 171  
      * be in a shutdown state or else null.
 172  
      */
 173  
     final public Broker getBroker ()
 174  
     {
 175  
         // this method can be unsynch. because the broker manages its own
 176  
         // state, plus the only time the _broker will be shutdown or null
 177  
         // is after the last servlet has shutdown--so why would anyone be
 178  
         // accessing us then? if they do the _broker will throw exceptions
 179  
         // complaining that it has been shut down, or they'll get a null here.
 180  2977
         return _broker;
 181  
     }
 182  
 
 183  
     /**
 184  
      * Get a new FastWriter.
 185  
      * A FastWriter is used when writing templates to an output stream
 186  
      *
 187  
      * @param out The output stream the FastWriter should write to.  Typically
 188  
      *           this will be your ServletOutputStream.  It can be null if
 189  
      *           only want the fast writer to buffer the output.
 190  
      * @param enctype the Encoding type to use
 191  
      * @deprecated
 192  
      */
 193  
     final public FastWriter getFastWriter (OutputStream out, String enctype)
 194  
             throws UnsupportedEncodingException
 195  
     {
 196  0
         return FastWriter.getInstance(_broker, out, enctype);
 197  
     }
 198  
 
 199  
 
 200  
     /**
 201  
      * Instantiate a new context.
 202  
      */
 203  
     final public Context getContext ()
 204  
     {
 205  2
         return new Context(_broker);
 206  
     }
 207  
 
 208  
     /**
 209  
      * Instantiate a new webcontext.
 210  
      */
 211  
     final public WebContext getWebContext (HttpServletRequest req,
 212  
                                            HttpServletResponse resp)
 213  
     {
 214  0
         return new WebContext(_broker, req, resp);
 215  
     }
 216  
 
 217  
 
 218  
     /**
 219  
      * Retrieve a template from the "template" provider.
 220  
      * @exception NotFoundException  if the template could not be found
 221  
      * @exception ResourceException  if the template could not be loaded
 222  
      */
 223  
     final public Template getTemplate (String key)
 224  
             throws ResourceException
 225  
     {
 226  1542
         return (Template) _tmplProvider.get(key);
 227  
     }
 228  
 
 229  
     /**
 230  
      * Retrieve a URL from the "url" provider. Equivalent to
 231  
      * getBroker().getValue("url",url)
 232  
      * @exception NotFoundException  if the template could not be found
 233  
      * @exception ResourceException  if the template could not be loaded
 234  
      */
 235  
     final public String getURL (String url)
 236  
             throws ResourceException
 237  
     {
 238  0
         return (String) _urlProvider.get(url);
 239  
     }
 240  
 
 241  
     /**
 242  
      * Retrieve configuration information from the "config" provider.
 243  
      * Equivalent to getBroker().get("config",key)
 244  
      * @exception NotFoundException could not locate requested information
 245  
      */
 246  
     final public String getConfig (String key)
 247  
             throws NotFoundException
 248  
     {
 249  
         try
 250  
         {
 251  0
             return (String) _broker.get("config", key);
 252  
         }
 253  0
         catch (NotFoundException e)
 254  
         {
 255  0
             throw e;
 256  
         }
 257  0
         catch (ResourceException e)
 258  
         {
 259  0
             throw new NotFoundException(e.toString(), e);
 260  
         }
 261  
     }
 262  
 
 263  
     /**
 264  
      * Get a log to write information to. Logger type names should be lower
 265  
      * case and short. They may be printed on every line of the log
 266  
      * file. The description is a longer explanation of the type of
 267  
      * log messages you intend to produce with this Logger object.
 268  
      */
 269  
     final public Logger getLog (String type, String description)
 270  
     {
 271  0
         return _log;
 272  
     }
 273  
 
 274  
     /**
 275  
      * Get a log using the type as the description
 276  
      */
 277  
     final public Logger getLog (String type)
 278  
     {
 279  0
         return _log;
 280  
     }
 281  
 
 282  
     /**
 283  
      * Convenience method for writing a template to an OutputStream.
 284  
      * This method takes care of all the typical work involved
 285  
      * in writing a template.<p>
 286  
      *
 287  
      * This method uses the default <code>TemplateOutputEncoding</code> specified in
 288  
      * WebMacro.defaults or your custom WebMacro.properties.
 289  
      *
 290  
      * @param templateName name of Template to write.  Must be accessible
 291  
      *                     via TemplatePath
 292  
      * @param out          where the output of the template should go
 293  
      * @param context      The Context (can be a WebContext too) used
 294  
      *                     during the template evaluation phase
 295  
      * @throws java.io.IOException if the template cannot be written to the
 296  
      *                             specified output stream
 297  
      * @throws ResourceException if the template name specified cannot be found
 298  
      * @throws PropertyException if a fatal error occured during the Template
 299  
      *                           evaluation phase
 300  
      */
 301  
     final public void writeTemplate (String templateName, java.io.OutputStream out,
 302  
                                      Context context)
 303  
             throws java.io.IOException, ResourceException, PropertyException
 304  
     {
 305  
 
 306  0
         writeTemplate(templateName, out,
 307  
                 getConfig(WMConstants.TEMPLATE_OUTPUT_ENCODING), context);
 308  0
     }
 309  
 
 310  
     /**
 311  
      * Convienence method for writing a template to an OutputStream.
 312  
      * This method takes care of all the typical work involved
 313  
      * in writing a template.
 314  
      *
 315  
      * @param templateName name of Template to write.  Must be accessible
 316  
      *                     via TemplatePath
 317  
      * @param out          where the output of the template should go
 318  
      * @param encoding     character encoding to use when writing the template
 319  
      *                     if the encoding is <code>null</code>, the default
 320  
      *                     <code>TemplateOutputEncoding</code> is used
 321  
      * @param context      The Context (can be a WebContext too) used
 322  
      *                     during the template evaluation phase
 323  
      * @throws java.io.IOException if the template cannot be written to the
 324  
      *                             specified output stream
 325  
      * @throws ResourceException if the template name specified cannot be found
 326  
      * @throws PropertyException if a fatal error occured during the Template
 327  
      *                           evaluation phase
 328  
      */
 329  
     final public void writeTemplate (String templateName, java.io.OutputStream out,
 330  
                                      String encoding, Context context)
 331  
             throws java.io.IOException, ResourceException, PropertyException
 332  
     {
 333  
 
 334  0
         if (encoding == null)
 335  0
             encoding = getConfig(WMConstants.TEMPLATE_OUTPUT_ENCODING);
 336  
 
 337  0
         Template tmpl = getTemplate(templateName);
 338  0
         tmpl.write(out, encoding, context);
 339  0
     }
 340  
 
 341  
     /**
 342  
      * Print the version, and quit
 343  
      */
 344  
     public static void main (String[] args)
 345  
     {
 346  0
         System.out.println("WebMacro v" + WebMacro.VERSION + ".  Built " + WebMacro.BUILD_DATE);
 347  0
     }
 348  
 
 349  
     /**
 350  
      * Close down this WM.  This will invoke destroy() on the Broker.
 351  
      * @see Broker#destroy()
 352  
      **/
 353  
     public void destroy() 
 354  
     {
 355  0
         getBroker().destroy();
 356  0
     }
 357  
 }