Coverage Report - org.webmacro.engine.BuildContext
 
Classes in this File Line Coverage Branch Coverage Complexity
BuildContext
37%
20/53
32%
11/34
3.778
 
 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.engine;
 25  
 
 26  
 import java.util.HashMap;
 27  
 import java.util.Map;
 28  
 
 29  
 import org.webmacro.Broker;
 30  
 import org.webmacro.Context;
 31  
 import org.webmacro.Macro;
 32  
 import org.webmacro.NotFoundException;
 33  
 import org.webmacro.ResourceException;
 34  
 import org.webmacro.Template;
 35  
 
 36  
 
 37  
 /**
 38  
  * Contains data structures which are manipulated during the
 39  
  * builder phase of parsing. It extends Map so that
 40  
  * user provided directives can store information in it during
 41  
  * the builder phase. Although WebMacro's built in directives
 42  
  * make no use of this hashtable (they use the other structures
 43  
  * added in the derived class), other user provided directives
 44  
  * might. Therefore you should adopt a sensible naming scheme for
 45  
  * your keys, to avoid conflicting with keys inserted by someone else.
 46  
  */
 47  
 public class BuildContext extends Context
 48  
 {
 49  
 
 50  224
     private final Map _types = new HashMap();
 51  224
     private final Map _macros = new HashMap();
 52  
 
 53  
     public BuildContext (Broker b)
 54  
     {
 55  224
         super(b);
 56  224
     }
 57  
 
 58  
     public final Parser getParser (String pname)
 59  
             throws NotFoundException
 60  
     {
 61  
         try
 62  
         {
 63  0
             return (Parser) getBroker().get("parser", pname);
 64  
         }
 65  0
         catch (NotFoundException e)
 66  
         {
 67  0
             throw e;
 68  
         }
 69  0
         catch (ResourceException e)
 70  
         {
 71  0
             throw new NotFoundException(e.toString(), e);
 72  
         }
 73  
     }
 74  
 
 75  
     /**
 76  
      * Find out whether the named variable is a tool, local variable,
 77  
      * or property variable.
 78  
      */
 79  
     public Object getVariableType (String name)
 80  
     {
 81  5834
         Object ret = _types.get(name);
 82  5834
         return (ret == null) ? Variable.PROPERTY_TYPE : ret;
 83  
     }
 84  
 
 85  
     /**
 86  
      * Declare whether the named variable is to be treated as a tool,
 87  
      * local variable, or property variable type.
 88  
      */
 89  
     public void setVariableType (String name, Object type)
 90  
     {
 91  0
         if (name == null)
 92  
         {
 93  0
             return;
 94  
         }
 95  0
         if (type == null)
 96  
         {
 97  0
             _types.remove(name);
 98  
         }
 99  
         else
 100  
         {
 101  0
             _types.put(name, type);
 102  
         }
 103  0
     }
 104  
 
 105  
     /**
 106  
      * Add a MacroDefinition to the build context.
 107  
      */
 108  
     public void putMacro (String name, MacroDefinition macro)
 109  
     {
 110  0
         _macros.put(name, macro);
 111  0
     }
 112  
 
 113  
     /**
 114  
      * Search for a MacroDefinition in the build context.
 115  
      */
 116  
     public MacroDefinition getMacro (String name)
 117  
     {
 118  0
         return (MacroDefinition) _macros.get(name);
 119  
     }
 120  
 
 121  
     /**
 122  
      * Add #macros and #params from the specified Template to
 123  
      * this bulid context.
 124  
      */
 125  
     public void mergeConstants (Template t)
 126  
     {
 127  0
         Map macros = t.getMacros();
 128  0
         Map params = t.getParameters();
 129  0
         if (macros != null)
 130  0
             _macros.putAll(macros);
 131  0
         if (params != null)
 132  0
             super.putAll(params);
 133  0
     }
 134  
 
 135  
     /**
 136  
      * Return the map of MacroDefinitions.
 137  
      */
 138  
     public Map getMacros ()
 139  
     {
 140  224
         return _macros;
 141  
     }
 142  
 
 143  
     /**
 144  
      * Create a variable (or resolve a constant at build time).
 145  
      * Used by various build() routines.
 146  
      */
 147  
     Object resolveVariableReference (Object names[])
 148  
             throws BuildException
 149  
     {
 150  5834
         Object v = null;
 151  
 
 152  5834
         if (names.length < 1)
 153  0
             throw new BuildException("Variable with name of length zero!");
 154  
 
 155  5834
         Object c[] = new Object[names.length];
 156  16818
         for (int i = 0; i < c.length; i++)
 157  
         {
 158  10984
             c[i] = (names[i] instanceof Builder) ?
 159  
                     ((Builder) names[i]).build(this) : names[i];
 160  
         }
 161  5834
         String firstName = c[0].toString();
 162  5834
         Object type = null;
 163  5834
         if (c[0] instanceof FunctionCall)
 164  
         {
 165  0
             type = FunctionVariable.TYPE;
 166  
         }
 167  
         else
 168  
         {
 169  5834
             type = getVariableType(firstName);
 170  
         }
 171  5834
         if (type == Variable.PROPERTY_TYPE)
 172  
         {
 173  5834
             if (containsKey(firstName))
 174  
             {
 175  0
                 Object expansion = get(firstName);
 176  0
                 if (expansion instanceof Macro)
 177  
                 {
 178  0
                     v = (c.length == 1) ? expansion
 179  
                             : new MacroPropertyVariable((Macro) expansion, c);
 180  
                 }
 181  
                 else
 182  
                 {
 183  0
                     v = (c.length == 1) ? expansion
 184  
                             : new ConstantPropertyVariable(expansion, c);
 185  
                 }
 186  0
             }
 187  
             else
 188  
             {
 189  5834
                 v = (c.length == 1)
 190  
                         ? (Object) new SimplePropertyVariable(c)
 191  
                         : (Object) new PropertyVariable(c);
 192  
             }
 193  
         }
 194  0
         else if (type == Variable.LOCAL_TYPE)
 195  
         {
 196  0
             v = new GlobalVariable(c);
 197  
         }
 198  0
         else if (type == FunctionVariable.TYPE)
 199  
         {
 200  0
             v = new FunctionVariable(c);
 201  
         }
 202  
         else
 203  
         {
 204  0
             throw new BuildException("Unrecognized Variable Type: " + type);
 205  
         }
 206  5834
         return v;
 207  
     }
 208  
 
 209  
 }
 210  
 
 211