Coverage report

  %line %branch
org.apache.turbine.services.pull.TurbinePull
18% 
100% 

 1  
 package org.apache.turbine.services.pull;
 2  
 
 3  
 /*
 4  
  * Copyright 2001-2005 The Apache Software Foundation.
 5  
  *
 6  
  * Licensed under the Apache License, Version 2.0 (the "License")
 7  
  * you may not use this file except in compliance with the License.
 8  
  * You may obtain a copy of the License at
 9  
  *
 10  
  *     http://www.apache.org/licenses/LICENSE-2.0
 11  
  *
 12  
  * Unless required by applicable law or agreed to in writing, software
 13  
  * distributed under the License is distributed on an "AS IS" BASIS,
 14  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15  
  * See the License for the specific language governing permissions and
 16  
  * limitations under the License.
 17  
  */
 18  
 
 19  
 import org.apache.turbine.services.TurbineServices;
 20  
 import org.apache.turbine.util.RunData;
 21  
 
 22  
 import org.apache.velocity.context.Context;
 23  
 
 24  
 /**
 25  
  * This is a Facade class for PullService.
 26  
  *
 27  
  * This class provides static methods that call related methods of the
 28  
  * implementation of the PullService used by the System, according to
 29  
  * the settings in TurbineResources.
 30  
  *
 31  
  * @author <a href="mailto:jvanzyl@periapt.com">Jason van Zyl</a>
 32  
  * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
 33  
  * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
 34  
  * @version $Id: TurbinePull.java 264148 2005-08-29 14:21:04Z henning $
 35  
  */
 36  0
 public abstract class TurbinePull
 37  
 {
 38  
     /**
 39  
      * Utility method for accessing the service
 40  
      * implementation
 41  
      *
 42  
      * @return a PullService implementation instance
 43  
      */
 44  
     public static PullService getService()
 45  
     {
 46  76
         return (PullService) TurbineServices
 47  
                 .getInstance().getService(PullService.SERVICE_NAME);
 48  
     }
 49  
 
 50  
     /**
 51  
      * Get the context containing global tools that will be
 52  
      * use as part of the Turbine Pull Model.
 53  
      *
 54  
      * @return A Context object which contains the
 55  
      *         Global Tool instances.
 56  
      */
 57  
     public static final Context getGlobalContext()
 58  
     {
 59  0
         return getService().getGlobalContext();
 60  
     }
 61  
 
 62  
     /**
 63  
      * Checks whether this service has been registered.  This is
 64  
      * required by the TurbineVelocityService so it can determine
 65  
      * whether to attempt to place the ToolBox in the context.
 66  
      * <p>
 67  
      * So users can use Turbine with templates in the traditional
 68  
      * manner. If the Pull Service is not listed in
 69  
      * <code>TurbineResources.props</code>, or no tools are specified
 70  
      * the TurbineVelocityService will behave in its traditional
 71  
      * manner.
 72  
      */
 73  
     public static final boolean isRegistered()
 74  
     {
 75  42
         return TurbineServices.getInstance()
 76  
                 .isRegistered(PullService.SERVICE_NAME);
 77  
     }
 78  
 
 79  
     /**
 80  
      * Return the absolute path of the resources directory
 81  
      * used by application tools.
 82  
      *
 83  
      * @return A directory path in the file system or null.
 84  
      */
 85  
     public static final String getAbsolutePathToResourcesDirectory()
 86  
     {
 87  0
         return getService().getAbsolutePathToResourcesDirectory();
 88  
     }
 89  
 
 90  
     /**
 91  
      * Return the resources directory. This is relative
 92  
      * to the webapp context.
 93  
      *
 94  
      * @return A directory path to the resources directory relative to the webapp root or null.
 95  
      */
 96  
     public static final String getResourcesDirectory()
 97  
     {
 98  26
         return getService().getResourcesDirectory();
 99  
     }
 100  
 
 101  
     /**
 102  
      * Populate the given context with all request, session
 103  
      * and persistent scope tools (it is assumed that the context
 104  
      * already wraps the global context, and thus already contains
 105  
      * the global tools).
 106  
      *
 107  
      * @param context a Velocity Context to populate
 108  
      * @param data a RunData object for request specific data
 109  
      */
 110  
     public static void populateContext(Context context, RunData data)
 111  
     {
 112  0
         getService().populateContext(context, data);
 113  0
     }
 114  
 
 115  
     /**
 116  
      * Refresh the global tools. This is necessary
 117  
      * for development work where tools depend
 118  
      * on configuration information. The configuration
 119  
      * information is typically cached after initialization
 120  
      * but during development you might want the tool
 121  
      * to refresh itself on each request.
 122  
      * <p>
 123  
      * If there are objects that don't implement
 124  
      * the ApplicationTool interface, then they won't
 125  
      * be refreshed.
 126  
      * @deprecated No longer needed as Pull and Velocity Service are now more separate.
 127  
      */
 128  
     public static final void refreshGlobalTools()
 129  
     {
 130  0
         getService().refreshGlobalTools();
 131  0
     }
 132  
 
 133  
     /**
 134  
      * Shoud we refresh the tools
 135  
      * on each request. For development purposes.
 136  
      *
 137  
      * @return true if we should refresh the tools on every request.
 138  
      * @deprecated No longer needed as Pull and Velocity Service are now more separate.
 139  
      */
 140  
     public static final boolean refreshToolsPerRequest()
 141  
     {
 142  0
         return getService().refreshToolsPerRequest();
 143  
     }
 144  
 
 145  
     /**
 146  
      * Release tool instances from the given context to the
 147  
      * object pool
 148  
      *
 149  
      * @param context a Velocity Context to release tools from
 150  
      */
 151  
     public static void releaseTools(Context context)
 152  
     {
 153  0
         getService().releaseTools(context);
 154  0
     }
 155  
 
 156  
     /**
 157  
      * Helper method that allows you to easily get a tool
 158  
      * from a Context. Essentially, it just does the cast
 159  
      * to an Application tool for you.
 160  
      *
 161  
      * @param context a Velocity Context to get tools from
 162  
      * @param name the name of the tool to get
 163  
      * @return ApplicationTool null if no tool could be found
 164  
      */
 165  
     public static ApplicationTool getTool(Context context,
 166  
                                           String name)
 167  
     {
 168  
         try
 169  
         {
 170  0
             return (ApplicationTool) context.get(name);
 171  
         }
 172  0
         catch (Exception e)
 173  
         {
 174  
         }
 175  0
         return null;
 176  
     }
 177  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.