Coverage report

  %line %branch
org.apache.commons.jelly.util.CommandLineParser$1
0% 
0% 

 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.util;
 18  
 
 19  
 import java.io.File;
 20  
 import java.io.FileWriter;
 21  
 import java.net.URL;
 22  
 import java.util.ArrayList;
 23  
 import java.util.Properties;
 24  
 import java.util.StringTokenizer;
 25  
 
 26  
 import org.apache.commons.cli.CommandLine;
 27  
 import org.apache.commons.cli.GnuParser;
 28  
 import org.apache.commons.cli.Options;
 29  
 import org.apache.commons.cli.Parser;
 30  
 import org.apache.commons.cli.ParseException;
 31  
 
 32  
 import org.apache.commons.jelly.Jelly;
 33  
 import org.apache.commons.jelly.JellyContext;
 34  
 import org.apache.commons.jelly.JellyException;
 35  
 import org.apache.commons.jelly.Script;
 36  
 import org.apache.commons.jelly.XMLOutput;
 37  
 
 38  
 /**
 39  
  * Utility class to parse command line options using CLI.
 40  
  * Using a separate class allows us to run Jelly without
 41  
  * CLI in the classpath when the command line interface
 42  
  * is not in use.
 43  
  *
 44  
  * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
 45  
  * @author Morgan Delagrange
 46  
  * @version $Revision: 1.7 $
 47  
  */
 48  
 public class CommandLineParser {
 49  
 
 50  
     protected static CommandLineParser _instance = new CommandLineParser();
 51  
 
 52  
     public static CommandLineParser getInstance() {
 53  
         return _instance;
 54  
     }
 55  
 
 56  
     /**
 57  
      * Parse out the command line options and configure
 58  
      * the give Jelly instance.
 59  
      *
 60  
      * @param args   options from the command line
 61  
      * @exception JellyException
 62  
      *                   if the command line could not be parsed
 63  
      */
 64  
     public void invokeCommandLineJelly(String[] args) throws JellyException {
 65  
         CommandLine cmdLine = null;
 66  
         try {
 67  
             cmdLine = parseCommandLineOptions(args);
 68  
         } catch (ParseException e) {
 69  
             throw new JellyException(e);
 70  
         }
 71  
 
 72  
         // get the -script option. If there isn't one then use args[0]
 73  
         String scriptFile = null;
 74  
         if (cmdLine.hasOption("script")) {
 75  
             scriptFile = cmdLine.getOptionValue("script");
 76  
         } else {
 77  
             scriptFile = args[0];
 78  
         }
 79  
 
 80  
         //
 81  
         // Use classloader to find file
 82  
         //
 83  
         URL url = ClassLoaderUtils.getClassLoader(getClass()).getResource(scriptFile);
 84  
         // check if the script file exists
 85  
         if (url == null && !(new File(scriptFile)).exists()) {
 86  
             throw new JellyException("Script file " + scriptFile + " not found");
 87  
         }
 88  
 
 89  
         try {
 90  
             // extract the -o option for the output file to use
 91  
             final XMLOutput output = cmdLine.hasOption("o") ?
 92  
                     XMLOutput.createXMLOutput(new FileWriter(cmdLine.getOptionValue("o"))) :
 93  
                     XMLOutput.createXMLOutput(System.out);
 94  
 
 95  
             Jelly jelly = new Jelly();
 96  
             jelly.setScript(scriptFile);
 97  
 
 98  
             Script script = jelly.compileScript();
 99  
 
 100  
             // add the system properties and the command line arguments
 101  
             JellyContext context = jelly.getJellyContext();
 102  
             context.setVariable("args", args);
 103  
             context.setVariable("commandLine", cmdLine);
 104  
             script.run(context, output);
 105  
 
 106  
             // now lets wait for all threads to close
 107  
             Runtime.getRuntime().addShutdownHook(new Thread() {
 108  0
                     public void run() {
 109  
                         try {
 110  0
                             output.close();
 111  0
                         }
 112  0
                         catch (Exception e) {
 113  
                             // ignore errors
 114  
                         }
 115  0
                     }
 116  
                 }
 117  
             );
 118  
 
 119  
         } catch (Exception e) {
 120  
             throw new JellyException(e);
 121  
         }
 122  
 
 123  
     }
 124  
 
 125  
     /**
 126  
      * Parse the command line using CLI. -o and -script are reserved for Jelly.
 127  
      * -Dsysprop=sysval is support on the command line as well.
 128  
      */
 129  
     public CommandLine parseCommandLineOptions(String[] args) throws ParseException {
 130  
         // create the expected options
 131  
         Options cmdLineOptions = new Options();
 132  
         cmdLineOptions.addOption("o", true, "Output file");
 133  
         cmdLineOptions.addOption("script", true, "Jelly script to run");
 134  
 
 135  
         // -D options will be added to the system properties
 136  
         Properties sysProps = System.getProperties();
 137  
 
 138  
         // filter the system property setting from the arg list
 139  
         // before passing it to the CLI parser
 140  
         ArrayList filteredArgList = new ArrayList();
 141  
 
 142  
         for (int i=0;i<args.length;i++) {
 143  
             String arg = args[i];
 144  
 
 145  
             // if this is a -D property parse it and add it to the system properties.
 146  
             // -D args will not be copied into the filteredArgList.
 147  
             if (arg.startsWith("-D") && (arg.length() > 2)) {
 148  
                 arg = arg.substring(2);
 149  
                 StringTokenizer toks = new StringTokenizer(arg, "=");
 150  
 
 151  
                 if (toks.countTokens() == 2) {
 152  
                     // add the tokens to the system properties
 153  
                     sysProps.setProperty(toks.nextToken(), toks.nextToken());
 154  
                 } else {
 155  
                     System.err.println("Invalid system property: " + arg);
 156  
                 }
 157  
 
 158  
             } else {
 159  
                 // add this to the filtered list of arguments
 160  
                 filteredArgList.add(arg);
 161  
 
 162  
                 // add additional "-?" options to the options object. if this is not done
 163  
                 // the only options allowed would be "-o" and "-script".
 164  
                 if (arg.startsWith("-") && arg.length() > 1) {
 165  
                     if (!(arg.equals("-o") && arg.equals("-script"))) {
 166  
                         cmdLineOptions.addOption(arg.substring(1, arg.length()), true, "dynamic option");
 167  
                     }
 168  
                 }
 169  
             }
 170  
         }
 171  
 
 172  
         // make the filteredArgList into an array
 173  
         String[] filterArgs = new String[filteredArgList.size()];
 174  
         filteredArgList.toArray(filterArgs);
 175  
 
 176  
         // parse the command line
 177  
         Parser parser = new GnuParser();
 178  
         return parser.parse(cmdLineOptions, filterArgs);
 179  
     }
 180  
 
 181  
 }

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