Coverage report

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

org.apache.commons.jelly.impl.Embedded

62%

85%

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.impl;

17

18

     import java.io.ByteArrayInputStream;

19

     import java.io.File;

20

     import java.io.IOException;

21

     import java.io.InputStream;

22

     import java.io.OutputStream;

23

     import java.io.OutputStreamWriter;

24

     import java.net.MalformedURLException;

25

     import java.net.URL;

26

27

     import org.apache.commons.jelly.Jelly;

28

     import org.apache.commons.jelly.JellyContext;

29

     import org.apache.commons.jelly.Script;

30

     import org.apache.commons.jelly.TagLibrary;

31

     import org.apache.commons.jelly.XMLOutput;

32

     import org.apache.commons.jelly.parser.XMLParser;

33

     import org.apache.commons.logging.Log;

34

     import org.apache.commons.logging.LogFactory;

35

     import org.xml.sax.SAXException;

36

37

     /**

38

      * @author <a href="mailto:vinayc@apache.org">Vinay Chandran</a>

39

      *

40

      * <p><code>Embedded</code> provides easy means to embed JellyEngine <br/>

41

      * and use Jelly scripts within an application</p>

42

      * A typical usage:<br/>

43

      *  <code><br/>

44

      *     Embedded embedded = new Embedded();<br/>

45

      *     embedded.setOutputStream(new ByteArrayOutputStream());<br/>

46

      *     embedded.setVariable("some-var","some-object");<br/>

47

      *     .....<br/>

48

      *     embedded.setScript(scriptAsString);<br/>

49

      *     //or one can do.<br/>

50

      *     //embedded.setScript(scriptAsInputStream);<br/>

51

      *     <br/>

52

      *     boolean bStatus=embedded.execute();<br/>

53

      *     if(!bStatus) //if error<br/>

54

      *     {<br/>

55

      *         String errorMsg=embedded.getErrorMsg();<br/>

56

      *     }<br/>

57

      *  </code>  <br/>

58

      *

59

      * @author <a href="mailto:vinayc@apache.org">Vinay Chandran</a>

60

      */

61

     public class Embedded {

62

         /** Jelly Engine */

63

26

         Jelly m_jellyEngine = new Jelly();

64

         /** JellyContext*/

65

26

         private JellyContext m_context = new JellyContext();

66

         /** Compiled Script Object*/

67

         private Script m_script;

68

         /** Input script as stream*/

69

         private InputStream m_inputStream;

70

         /** Output Stream */

71

         private OutputStream m_outputStream;

72

         /** Output(default System.out) */

73

26

         private XMLOutput m_output =

74

             XMLOutput.createXMLOutput(new OutputStreamWriter(System.out));

75

         /** Exception thrown during compilation of script*/

76

         Exception m_scriptCompilationException;

77

         /** boolean value indicating whether the script has been successfully compiled or NOT */

78

26

         boolean m_scriptCompiled = false;

79

         /** ErrorMsg*/

80

         private String m_errorMsg;

81

         /** The Log to which logging calls will be made. */

82

26

         private static final Log log = LogFactory.getLog(Embedded.class);

83

84

         /**

85

          * Default Constructor

86

          *

87

          */

88

26

         public Embedded() {

89

             //m_context.setClassLoader(new TagLibraryClassLoader(m_context));

90

26

         }

91

92

         /**

93

          * Method setContext.

94

          * @param context

95

          */

96

         public void setContext(JellyContext context) {

97

0

             m_context = context;

98

0

         }

99

100

         /**

101

          * Method getContext.

102

          * @return JellyContext

103

          */

104

         public JellyContext getContext() {

105

0

             return m_context;

106

         }

107

108

         /**

109

          * Set a new variable within the context for the script to use.

110

          * @param name

111

          * @param value

112

          */

113

         public void setVariable(String name, Object value) {

114

0

             m_context.setVariable(name, value);

115

0

         }

116

117

         /**

118

          * Set the input script

119

          * @param scriptAsString

120

          */

121

         public void setScript(String scriptAsString) {

122

123

             try {

124

26

                 URL url = resolveURL(scriptAsString);

125

0

                 m_inputStream = url.openStream();

126

             }

127

26

             catch (MalformedURLException e) {

128

                 //Encapsulate the string within

129

26

                 m_inputStream = new ByteArrayInputStream(scriptAsString.getBytes());

130

             }

131

0

             catch (IOException e) {

132

                 //Error reading from the URL

133

0

                 m_inputStream = null;

134

26

             }

135

136

26

             compileScriptAndKeep();

137

138

26

         }

139

140

         /**

141

          * @return the URL for the relative file name or absolute URL

142

          */

143

         private URL resolveURL(String name) throws MalformedURLException {

144

26

             File file = new File(name);

145

26

             if (file.exists()) {

146

0

                 return file.toURL();

147

             }

148

26

             return new URL(name);

149

         }

150

151

         /**

152

          * Set the input stream

153

          * @param scriptAsInputStream

154

          */

155

         public void setScript(InputStream scriptAsInputStream) {

156

13

             m_inputStream = scriptAsInputStream;

157

13

             compileScriptAndKeep();

158

13

         }

159

160

         /**

161

          * Compile the script

162

          */

163

         private void compileScriptAndKeep() {

164

39

             XMLParser parser = new XMLParser();

165

39

             parser.setContext(m_context);

166

39

             m_scriptCompiled = false;

167

             try {

168

39

                 m_script = parser.parse(m_inputStream);

169

26

                 m_script = m_script.compile();

170

26

                 m_scriptCompiled = true;

171

             }

172

0

             catch (IOException e) {

173

0

                 m_scriptCompilationException = e;

174

             }

175

13

             catch (SAXException e) {

176

13

                 m_scriptCompilationException = e;

177

             }

178

0

             catch (Exception e) {

179

0

                 m_scriptCompilationException = e;

180

39

             }

181

39

         }

182

183

         /**

184

          * Method setOutputStream.

185

          * @param outputStream

186

          */

187

         public void setOutputStream(OutputStream outputStream) {

188

26

             m_outputStream = outputStream;

189

26

             m_output =

190

                 XMLOutput.createXMLOutput(new OutputStreamWriter(m_outputStream));

191

26

         }

192

193

         /**

194

          * Registers the given tag library class name against the given namespace URI.

195

          * The class will be loaded via the given ClassLoader

196

          * This should be called before the parser is used.

197

          */

198

         public void registerTagLibrary(String namespaceURI, String className) {

199

0

             if (m_context != null)

200

0

                 m_context.registerTagLibrary(namespaceURI, className);

201

0

         }

202

203

         /**

204

          * Registers the given tag library against the given namespace URI.

205

          * This should be called before the parser is used.

206

          */

207

         public void registerTagLibrary(String namespaceURI, TagLibrary taglib) {

208

0

             if (m_context != null)

209

0

                 m_context.registerTagLibrary(namespaceURI, taglib);

210

0

         }

211

212

         /**

213

          * Returns the errorMsg.

214

          * @return String

215

          */

216

         public String getErrorMsg() {

217

13

             return m_errorMsg;

218

         }

219

220

         /**

221

          * Sets the errorMsg.

222

          * @param errorMsg The errorMsg to set

223

          */

224

         private void setErrorMsg(String errorMsg) {

225

13

             m_errorMsg = errorMsg;

226

13

         }

227

228

         /**

229

          * Execute the jelly script and capture the errors (ifany)within.

230

          *

231

          * @throws JellyException

232

          */

233

         public boolean execute() {

234

39

             if (log.isDebugEnabled())

235

0

                 log.debug("Starting Execution");

236

             //If script has not been compiled then return the errorMsg that occured during compilation

237

39

             if (!m_scriptCompiled) {

238

13

                 if (log.isErrorEnabled())

239

13

                     log.error(m_scriptCompilationException.getMessage());

240

13

                 setErrorMsg(m_scriptCompilationException.getMessage());

241

13

                 return false;

242

             }

243

26

             if (m_inputStream == null) {

244

0

                 if (log.isErrorEnabled())

245

0

                     log.error("[Error] Input script-resource NOT accessible");

246

0

                 setErrorMsg("[Error] Input script-resource NOT accessible");

247

0

                 return false;

248

             }

249

             try {

250

26

                 m_script.run(m_context, m_output);

251

26

                 m_outputStream.close();

252

26

                 m_output.flush();

253

             }

254

0

             catch (Exception e) {

255

0

                 if (log.isErrorEnabled())

256

0

                     log.error(e.getMessage());

257

0

                 setErrorMsg(e.getMessage());

258

0

                 return false;

259

26

             }

260

26

             if (log.isDebugEnabled())

261

0

                 log.debug("Done Executing");

262

26

             return true;

263

         }

264

265

     }

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