Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.jelly.TagSupport |
75% |
95% |

1 |  |
     /*
2 |  |
      * Copyright 2002,2004 The Apache Software Foundation.
3 |  |
      *
4 |  |
      * Licensed under the Apache License, Version 2.0 (the "License");
5 |  |
      * you may not use this file except in compliance with the License.
6 |  |
      * You may obtain a copy of the License at
7 |  |
      *
8 |  |
      *      http://www.apache.org/licenses/LICENSE-2.0
9 |  |
      *
10 |  |
      * Unless required by applicable law or agreed to in writing, software
11 |  |
      * distributed under the License is distributed on an "AS IS" BASIS,
12 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  |
      * See the License for the specific language governing permissions and
14 |  |
      * limitations under the License.
15 |  |
      */
16 |  |
     package org.apache.commons.jelly;
17 |  |
18 |  |
     import java.io.StringWriter;
19 |  |
     import java.util.Arrays;
20 |  |
     import java.util.Collection;
21 |  |
     import java.util.Iterator;
22 |  |
23 |  |
     import org.apache.commons.jelly.util.TagUtils;
24 |  |
25 |  |
     /** <p><code>TagSupport</code> an abstract base class which is useful to
26 |  |
       * inherit from if developing your own tag.</p>
27 |  |
       *
28 |  |
       * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
29 |  |
       * @version $Revision: 155420 $
30 |  |
       */
31 |  |
32 |  |
     public abstract class TagSupport implements Tag {
33 |  |
34 |  |
         /** the parent of this tag */
35 |  |
         protected Tag parent;
36 |  |
37 |  |
         /** the body of the tag */
38 |  |
         protected Script body;
39 |  |
         /** The current context */
40 |  |
41 |  |
         protected Boolean shouldTrim;
42 |  |
         protected boolean hasTrimmed;
43 |  |
44 |  |
         protected JellyContext context;
45 |  |
46 |  |
         /** whether xml text should be escaped */
47 | 10309 |
         private boolean escapeText = true;
48 |  |
49 |  |
         /**
50 |  |
          * Searches up the parent hierarchy from the given tag
51 |  |
          * for a Tag of the given type
52 |  |
          *
53 |  |
          * @param from the tag to start searching from
54 |  |
          * @param tagClass the type of the tag to find
55 |  |
          * @return the tag of the given type or null if it could not be found
56 |  |
          */
57 |  |
         public static Tag findAncestorWithClass(Tag from, Class tagClass) {
58 |  |
             // we could implement this as
59 |  |
             //  return findAncestorWithClass(from,Collections.singleton(tagClass));
60 |  |
             // but this is so simple let's save the object creation for now
61 | 3120 |
             while (from != null) {
62 | 2899 |
                 if (tagClass.isInstance(from)) {
63 | 2444 |
                     return from;
64 |  |
                 }
65 | 455 |
                 from = from.getParent();
66 | 455 |
             }
67 | 221 |
             return null;
68 |  |
         }
69 |  |
70 |  |
         /**
71 |  |
          * Searches up the parent hierarchy from the given tag
72 |  |
          * for a Tag matching one or more of given types.
73 |  |
          *
74 |  |
          * @param from the tag to start searching from
75 |  |
          * @param tagClasses a Collection of Class types that might match
76 |  |
          * @return the tag of the given type or null if it could not be found
77 |  |
          */
78 |  |
         public static Tag findAncestorWithClass(Tag from, Collection tagClasses) {
79 | 0 |
             while (from != null) {
80 | 0 |
                 for(Iterator iter = tagClasses.iterator();iter.hasNext();) {
81 | 0 |
                     Class klass = (Class)(iter.next());
82 | 0 |
                     if (klass.isInstance(from)) {
83 | 0 |
                         return from;
84 |  |
                     }
85 | 0 |
                 }
86 | 0 |
                 from = from.getParent();
87 | 0 |
             }
88 | 0 |
             return null;
89 |  |
         }
90 |  |
91 |  |
         /**
92 |  |
          * Searches up the parent hierarchy from the given tag
93 |  |
          * for a Tag matching one or more of given types.
94 |  |
          *
95 |  |
          * @param from the tag to start searching from
96 |  |
          * @param tagClasses an array of types that might match
97 |  |
          * @return the tag of the given type or null if it could not be found
98 |  |
          * @see #findAncestorWithClass(Tag,Collection)
99 |  |
          */
100 |  |
         public static Tag findAncestorWithClass(Tag from, Class[] tagClasses) {
101 | 0 |
             return findAncestorWithClass(from,Arrays.asList(tagClasses));
102 |  |
         }
103 |  |
104 | 10309 |
         public TagSupport() {
105 | 10309 |
         }
106 |  |
107 | 0 |
         public TagSupport(boolean shouldTrim) {
108 | 0 |
             setTrim( shouldTrim );
109 | 0 |
         }
110 |  |
111 |  |
         /**
112 |  |
          * Sets whether whitespace inside this tag should be trimmed or not.
113 |  |
          * Defaults to true so whitespace is trimmed
114 |  |
          */
115 |  |
         public void setTrim(boolean shouldTrim) {
116 | 65 |
             if ( shouldTrim ) {
117 | 39 |
                 this.shouldTrim = Boolean.TRUE;
118 | 39 |
             }
119 |  |
             else {
120 | 26 |
                 this.shouldTrim = Boolean.FALSE;
121 |  |
             }
122 | 65 |
         }
123 |  |
124 |  |
         public boolean isTrim() {
125 | 9230 |
             if ( this.shouldTrim == null ) {
126 | 6487 |
                 Tag parent = getParent();
127 | 6487 |
                 if ( parent == null ) {
128 | 2392 |
                     return true;
129 |  |
                 }
130 |  |
                 else {
131 | 4095 |
                     if ( parent instanceof TagSupport ) {
132 | 4095 |
                         TagSupport parentSupport = (TagSupport) parent;
133 |  |
134 | 4095 |
                         this.shouldTrim = ( parentSupport.isTrim() ? Boolean.TRUE : Boolean.FALSE );
135 | 4095 |
                     }
136 |  |
                     else {
137 | 0 |
                         this.shouldTrim = Boolean.TRUE;
138 |  |
                     }
139 |  |
                 }
140 |  |
             }
141 |  |
142 | 6838 |
             return this.shouldTrim.booleanValue();
143 |  |
         }
144 |  |
145 |  |
         /** @return the parent of this tag */
146 |  |
         public Tag getParent() {
147 | 9607 |
             return parent;
148 |  |
         }
149 |  |
150 |  |
         /** Sets the parent of this tag */
151 |  |
         public void setParent(Tag parent) {
152 | 9854 |
             this.parent = parent;
153 | 9854 |
         }
154 |  |
155 |  |
         /** @return the body of the tag */
156 |  |
         public Script getBody() {
157 | 6890 |
             if (! hasTrimmed) {
158 | 5135 |
                 hasTrimmed = true;
159 | 5135 |
                 if (isTrim()) {
160 | 5109 |
                     trimBody();
161 |  |
                 }
162 |  |
             }
163 | 6890 |
             return body;
164 |  |
         }
165 |  |
166 |  |
         /** Sets the body of the tag */
167 |  |
         public void setBody(Script body) {
168 | 9854 |
             this.body = body;
169 | 9854 |
             this.hasTrimmed = false;
170 | 9854 |
         }
171 |  |
172 |  |
         /** @return the context in which the tag will be run */
173 |  |
         public JellyContext getContext() {
174 | 91 |
             return context;
175 |  |
         }
176 |  |
177 |  |
         /** Sets the context in which the tag will be run */
178 |  |
         public void setContext(JellyContext context) throws JellyTagException {
179 | 12571 |
             this.context = context;
180 | 12571 |
         }
181 |  |
182 |  |
         /**
183 |  |
          * Invokes the body of this tag using the given output
184 |  |
          */
185 |  |
         public void invokeBody(XMLOutput output) throws JellyTagException {
186 | 6617 |
             getBody().run(context, output);
187 | 6071 |
         }
188 |  |
189 |  |
         // Implementation methods
190 |  |
         //-------------------------------------------------------------------------
191 |  |
         /**
192 |  |
          * Searches up the parent hierarchy for a Tag of the given type.
193 |  |
          * @return the tag of the given type or null if it could not be found
194 |  |
          */
195 |  |
         protected Tag findAncestorWithClass(Class parentClass) {
196 | 2665 |
             return findAncestorWithClass(getParent(), parentClass);
197 |  |
         }
198 |  |
199 |  |
         /**
200 |  |
          * Searches up the parent hierarchy for a Tag of one of the given types.
201 |  |
          * @return the tag of the given type or null if it could not be found
202 |  |
          * @see #findAncestorWithClass(Collection)
203 |  |
          */
204 |  |
         protected Tag findAncestorWithClass(Class[] parentClasses) {
205 | 0 |
             return findAncestorWithClass(getParent(),parentClasses);
206 |  |
         }
207 |  |
208 |  |
         /**
209 |  |
          * Searches up the parent hierarchy for a Tag of one of the given types.
210 |  |
          * @return the tag of the given type or null if it could not be found
211 |  |
          */
212 |  |
         protected Tag findAncestorWithClass(Collection parentClasses) {
213 | 0 |
             return findAncestorWithClass(getParent(),parentClasses);
214 |  |
         }
215 |  |
216 |  |
         /**
217 |  |
          * Executes the body of the tag and returns the result as a String.
218 |  |
          *
219 |  |
          * @return the text evaluation of the body
220 |  |
          */
221 |  |
         protected String getBodyText() throws JellyTagException {
222 | 416 |
             return getBodyText(escapeText);
223 |  |
         }
224 |  |
225 |  |
         /**
226 |  |
          * Executes the body of the tag and returns the result as a String.
227 |  |
          *
228 |  |
          * @param shouldEscape Signal if the text should be escaped.
229 |  |
          *
230 |  |
          * @return the text evaluation of the body
231 |  |
          */
232 |  |
         protected String getBodyText(boolean shouldEscape) throws JellyTagException {
233 | 572 |
             StringWriter writer = new StringWriter();
234 | 572 |
             invokeBody(XMLOutput.createXMLOutput(writer, shouldEscape));
235 | 572 |
             return writer.toString();
236 |  |
         }
237 |  |
238 |  |
239 |  |
         /**
240 |  |
          * Find all text nodes inside the top level of this body and
241 |  |
          * if they are just whitespace then remove them
242 |  |
          */
243 |  |
         protected void trimBody() {
244 | 5109 |
             TagUtils.trimScript(body);
245 | 5109 |
         }
246 |  |
247 |  |
         /**
248 |  |
          * Returns whether the body of this tag will be escaped or not.
249 |  |
          */
250 |  |
         public boolean isEscapeText() {
251 | 78 |
             return escapeText;
252 |  |
         }
253 |  |
254 |  |
         /**
255 |  |
          * Sets whether the body of the tag should be escaped as text (so that &lt; and &gt; are
256 |  |
          * escaped as &amp;lt; and &amp;gt;), which is the default or leave the text as XML.
257 |  |
          */
258 |  |
         public void setEscapeText(boolean escapeText) {
259 | 26 |
             this.escapeText = escapeText;
260 | 26 |
         }
261 |  |
     }

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