Coverage report

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

org.apache.commons.jelly.Jelly

50%

75%

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

17

     package org.apache.commons.jelly;

18

19

     import java.io.File;

20

     import java.io.InputStream;

21

     import java.io.FileInputStream;

22

     import java.io.IOException;

23

     import java.net.MalformedURLException;

24

     import java.net.URL;

25

     import java.util.Enumeration;

26

     import java.util.Properties;

27

28

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

29

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

30

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

31

     import org.apache.commons.logging.Log;

32

     import org.apache.commons.logging.LogFactory;

33

34

     import org.xml.sax.SAXException;

35

36

     /**

37

      * <p><code>Jelly</code> is a helper class which is capable of

38

      * running a Jelly script. This class can be used from the command line

39

      * or can be used as the basis of an Ant task.</p> Command line usage is as follows:

40

      *

41

      * <pre>

42

      * jelly [scriptFile] [-script scriptFile -o outputFile -Dsysprop=syspropval]

43

      * </pre>

44

      *

45

      * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>

46

      * @version $Revision: 155420 $

47

      */

48

     public class Jelly {

49

50

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

51

520

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

52

53

         /** The JellyContext to use */

54

         private JellyContext context;

55

56

         /** The URL of the script to execute */

57

         private URL url;

58

59

         /** The URL of the root context for other scripts */

60

         private URL rootContext;

61

62

         /** Whether we have loaded the properties yet */

63

1066

         private boolean loadedProperties = false;

64

65

         /**

66

          * whether to override the default namespace

67

          */

68

1066

         private String defaultNamespaceURI = null;

69

70

         /**

71

          * whether or not to validate the Jelly script

72

          */

73

1066

         private boolean validateXML = false;

74

75

1066

         public Jelly() {

76

1066

         }

77

78

         /**

79

          * Usage: jelly [scriptFile] [-script scriptFile -o outputFile -Dsysprop=syspropval]

80

          */

81

         public static void main(String[] args) throws Exception {

82

83

             try {

84

0

                 if (args.length <= 0) {

85

0

                     System.out.println("Usage: jelly [scriptFile] [-script scriptFile -o outputFile -Dsysprop=syspropval]");

86

0

                     return;

87

                 }

88

89

                 // parse the command line options using CLI

90

                 // using a separate class to avoid unnecessary

91

                 // dependencies

92

0

                 CommandLineParser.getInstance().invokeCommandLineJelly(args);

93

             }

94

0

             catch (JellyException e) {

95

0

                 Throwable cause = e.getCause();

96

97

0

                 if (cause == null) {

98

0

                     e.printStackTrace();

99

0

                 } else {

100

0

                     cause.printStackTrace();

101

                 }

102

0

             }

103

0

         }

104

105

106

         public static String getJellyVersion() {

107

0

             return readBuildTimestampResource("jelly-version.txt");

108

         }

109

110

         public static String getJellyBuildDate() {

111

0

             return readBuildTimestampResource("jelly-build-date.txt");

112

         }

113

114

         private static String readBuildTimestampResource(String name) {

115

0

             java.io.Reader in = null;

116

             try {

117

0

                 java.io.StringWriter w = new java.io.StringWriter();

118

0

                 in = new java.io.InputStreamReader(Jelly.class.getResourceAsStream(name),"utf-8");

119

                 int r;

120

0

                 while ( (r=in.read()) >= 0 ) {

121

0

                     w.write((char) r);

122

0

                 }

123

0

                 return w.toString();

124

0

             } catch(Exception ex) {

125

0

                 ex.printStackTrace();

126

0

                 try { in.close(); } catch(Exception e) {}

127

0

                 throw new IllegalStateException("Resource \"" + name + "\" not found.");

128

             }

129

         }

130

131

132

133

         /**

134

          * Compiles the script

135

          */

136

         public Script compileScript() throws JellyException {

137

845

             if (! loadedProperties) {

138

819

                 loadedProperties = true;

139

819

                 loadJellyProperties();

140

             }

141

142

845

             XMLParser parser = new XMLParser();

143

             try {

144

845

                 parser.setContext(getJellyContext());

145

0

             } catch (MalformedURLException e) {

146

0

                 throw new JellyException(e.toString());

147

845

             }

148

149

845

             Script script = null;

150

             try {

151

845

                 parser.setDefaultNamespaceURI(this.defaultNamespaceURI);

152

845

                 parser.setValidating(this.validateXML);

153

845

                 script = parser.parse(getUrl());

154

806

                 script = script.compile();

155

806

                 if (log.isDebugEnabled()) {

156

0

                    log.debug("Compiled script: " + getUrl());

157

                 }

158

0

             } catch (IOException e) {

159

0

                 throw new JellyException("could not parse Jelly script",e);

160

39

             } catch (SAXException e) {

161

39

                 throw new JellyException("could not parse Jelly script",e);

162

806

             }

163

164

806

             return script;

165

         }

166

167

168

         // Properties

169

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

170

171

         /**

172

          * Sets the script URL to use as an absolute URL or a relative filename

173

          */

174

         public void setScript(String script) throws MalformedURLException {

175

13

             setUrl(resolveURL(script));

176

13

         }

177

178

         public URL getUrl() {

179

1664

             return url;

180

         }

181

182

         /**

183

          * Sets the script URL to use

184

          */

185

         public void setUrl(URL url) {

186

819

             this.url = url;

187

819

         }

188

189

         /**

190

          * Gets the root context

191

          */

192

         public URL getRootContext() throws MalformedURLException {

193

819

             if (rootContext == null) {

194

819

                 rootContext = new File(System.getProperty("user.dir")).toURL();

195

             }

196

819

             return rootContext;

197

         }

198

199

         /**

200

          * Sets the root context

201

          */

202

         public void setRootContext(URL rootContext) {

203

0

             this.rootContext = rootContext;

204

0

         }

205

206

         /**

207

          * The context to use

208

          */

209

         public JellyContext getJellyContext() throws MalformedURLException {

210

845

             if (context == null) {

211

                 // take off the name off the URL

212

819

                 String text = getUrl().toString();

213

819

                 int idx = text.lastIndexOf('/');

214

819

                 text = text.substring(0, idx + 1);

215

819

                 context = new JellyContext(getRootContext(), <span class="keyword">new URL(text));

216

             }

217

845

             return context;

218

         }

219

220

221

         /**

222

          * Set the jelly namespace to use for unprefixed elements.

223

          * Will be overridden by an explicit namespace in the

224

          * XML document.

225

          *

226

          * @param namespace jelly namespace to use (e.g. 'jelly:core')

227

          */

228

         public void setDefaultNamespaceURI(String namespace) {

229

26

             this.defaultNamespaceURI = namespace;

230

26

         }

231

232

         /**

233

          * When set to true, the XML parser will attempt to validate

234

          * the Jelly XML before converting it into a Script.

235

          *

236

          * @param validate whether or not to validate

237

          */

238

         public void setValidateXML(boolean validate) {

239

65

             this.validateXML = validate;

240

65

         }

241

242

         // Implementation methods

243

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

244

         /**

245

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

246

          */

247

         protected URL resolveURL(String name) throws MalformedURLException {

248

249

13

             URL resourceUrl = ClassLoaderUtils.getClassLoader(getClass()).getResource(name);

250

13

             if (resourceUrl == null)

251

             {

252

13

                 File file = new File(name);

253

13

                 if (file.exists()) {

254

0

                     return file.toURL();

255

                 }

256

13

                 return new URL(name);

257

             } else {

258

0

                 return resourceUrl;

259

             }

260

         }

261

262

         /**

263

          * Attempts to load jelly.properties from the current directory,

264

          * the users home directory or from the classpath

265

          */

266

         protected void loadJellyProperties() {

267

819

             InputStream is = null;

268

269

819

             String userDir = System.getProperty("user.home");

270

819

             File f = new File(userDir + File.separator + "jelly.properties");

271

819

             loadProperties(f);

272

273

819

             f = new File("jelly.properties");

274

819

             loadProperties(f);

275

276

277

819

             is = ClassLoaderUtils.getClassLoader(getClass()).getResourceAsStream("jelly.properties");

278

819

             if (is != null) {

279

                 try {

280

0

                     loadProperties(is);

281

                 }

282

0

                 catch (Exception e) {

283

0

                     log.error( "Caught exception while loading jelly.properties from the classpath. Reason: " + e, e );

284

0

                 }

285

             }

286

819

         }

287

288

         /**

289

          * Load properties from a file into the context

290

          * @param f

291

          */

292

         private void loadProperties(File f) {

293

1638

             InputStream is = null;

294

             try {

295

1638

                 if (f.exists()) {

296

0

                     is = new FileInputStream(f);

297

0

                     loadProperties(is);

298

                 }

299

0

             } catch (Exception e) {

300

0

                 log.error( "Caught exception while loading: " + f.getName() + ". Reason: " + e, e );

301

             } finally {

302

1638

                 if (is != null) {

303

                     try {

304

0

                         is.close();

305

0

                     } catch (IOException e) {

306

0

                         if (log.isDebugEnabled()) log.debug("error closing property input stream", e);

307

0

                     }

308

0

                 }

309

0

             }

310

1638

         }

311

312

         /**

313

          * Loads the properties from the given input stream

314

          */

315

         protected void loadProperties(InputStream is) throws IOException {

316

0

             JellyContext theContext = getJellyContext();

317

0

             Properties props = new Properties();

318

0

             props.load(is);

319

0

             Enumeration propsEnum = props.propertyNames();

320

0

             while (propsEnum.hasMoreElements()) {

321

0

                 String key = (String) propsEnum.nextElement();

322

0

                 String value = props.getProperty(key);

323

324

                 // @todo we should parse the value in case its an Expression

325

0

                 theContext.setVariable(key, value);

326

0

             }

327

0

         }

328

     }

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