Coverage report

| %line | %branch
--- | --- | ---

org.apache.commons.jelly.tags.core.InvokeStaticTag

80%

98%

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.tags.core;

17

18

     import java.lang.reflect.InvocationTargetException;

19

     import java.lang.reflect.Method;

20

     import java.util.ArrayList;

21

     import java.util.List;

22

23

     import org.apache.commons.jelly.JellyTagException;

24

     import org.apache.commons.jelly.MissingAttributeException;

25

     import org.apache.commons.jelly.TagSupport;

26

     import org.apache.commons.jelly.XMLOutput;

27

     import org.apache.commons.jelly.util.ClassLoaderUtils;

28

29

     /**

30

       * A Tag which can invoke a static method on a class, without an

31

       * instance of the class being needed.

32

       * <p>

33

       * Like the {@link InvokeTag}, this tag can take a set of

34

       * arguments using the {@link ArgTag}.

35

       * </p>

36

       * <p>

37

       *  The following attributes are required:<br />

38

       * <ul>

39

       *   <li>var - The variable to assign the return of the method call to</li>

40

       *   <li>method - The name of the static method to invoke</li>

41

       *   <li>className - The name of the class containing the static method</li>

42

       * </ul>

43

       * </p>

44

       *

45

       * @author <a href="mailto:robert@bull-enterprises.com>Robert McIntosh</a>

46

       * @version $Revision: 155420 $

47

       */

48

     public class InvokeStaticTag extends TagSupport implements ArgTagParent {

49

50

         /** the variable exported */

51

         private String var;

52

53

         /** the variable where the method's exception is exported */

54

         private String exceptionVar;

55

56

         /** the method to invoke */

57

         private String methodName;

58

59

         /** the object to invoke the method on */

60

         private String className;

61

62

65

         private List paramTypes = new ArrayList();

63

65

         private List paramValues = new ArrayList();

64

65

65

         public InvokeStaticTag() {

66

65

         }

67

68

         /**

69

          * Sets the name of the variable exported by this tag

70

          *

71

          * @param var The variable name

72

          */

73

         public void setVar(String var) {

74

39

             this.var = <span class="keyword">var;

75

39

         }

76

77

         /** Sets the name of a variable that exports the exception thrown by

78

          * the method's invocation (if any)

79

          */

80

         public void setExceptionVar(String var) {

81

13

             this.exceptionVar = var;

82

13

         }

83

84

         /**

85

          * Sets the name of the method to invoke

86

          *

87

          * @param method The method name

88

          */

89

         public void setMethod(String methodName) {

90

65

             this.methodName = methodName;

91

65

         }

92

93

         /**

94

          * Sets the fully qualified class name containing the static method

95

          *

96

          * @param className The name of the class

97

          */

98

         public void setClassName(String className) {

99

65

             this.className = className;

100

65

         }

101

102

         /**

103

          * Adds an argument to supply to the method

104

          *

105

          * @param type The Class type of the argument

106

          * @param value The value of the argument

107

          */

108

         public void addArgument(Class type, Object value) {

109

91

             paramTypes.add(type);

110

91

             paramValues.add(value);

111

91

         }

112

113

         // Tag interface

114

         //-------------------------------------------------------------------------

115

         public void doTag(XMLOutput output) throws JellyTagException {

116

             try {

117

65

                 if ( null == methodName) {

118

0

                     throw new MissingAttributeException( "method" );

119

                 }

120

65

                 invokeBody(output);

121

122

65

                 Object[] values = paramValues.toArray();

123

65

                 Class[] types = (Class[])(paramTypes.toArray(new Class[paramTypes.size()]));

124

65

                 Method method = loadClass().getMethod( methodName, types );

125

65

                 Object result = method.invoke( null, values );

126

39

                 if(null != var) {

127

39

                     context.setVariable(var, result);

128

                 }

129

130

52

                 ArgTag parentArg = (ArgTag)(findAncestorWithClass(ArgTag.class));

131

39

                 if(null != parentArg) {

132

0

                     parentArg.setValue(result);

133

                 }

134

             }

135

0

             catch (ClassNotFoundException e) {

136

0

                 throw createLoadClassFailedException(e);

137

             }

138

0

             catch (NoSuchMethodException e) {

139

0

                 throw createLoadClassFailedException(e);

140

             }

141

0

             catch (IllegalAccessException e) {

142

0

                 throw createLoadClassFailedException(e);

143

             }

144

26

             catch (InvocationTargetException e) {

145

26

                 if(null != exceptionVar) {

146

13

                     context.setVariable(exceptionVar,e.getTargetException());

147

13

                 } else {

148

13

                     throw new JellyTagException("method " + methodName +

149

                         " threw exception: "+ e.getTargetException().getMessage(),

150

                         e.getTargetException() );

151

                 }

152

             }

153

             finally {

154

65

                 paramTypes.clear();

155

65

                 paramValues.clear();

156

65

             }

157

52

         }

158

159

         // Tag interface

160

         //-------------------------------------------------------------------------

161

162

         /**

163

          * Loads the class using either the class loader which loaded me or the

164

          * current threads context class loader

165

          */

166

         protected Class loadClass() throws ClassNotFoundException {

167

65

             return ClassLoaderUtils.loadClass(className, getClass());

168

         }

169

170

         /**

171

          * Factory method to create a new JellyTagException instance from a given

172

          * failure exception

173

          * @param e is the exception which occurred attempting to load the class

174

          * @return JellyTagException

175

          */

176

         protected JellyTagException createLoadClassFailedException(Exception e) {

177

0

             return new JellyTagException(

178

                 "Could not load class: " + className + ". Reason: " + e, e

179

             );

180

         }

181

     }

182

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