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.